scriptJ(TM) is a general purpose programming language for implementing
discretionary, adaptive concurrency that manages resources and demand. It is
differentiated from other concurrent languages by the following: - Universality
o Everything in the language is accomplished using message passing including
the very definition of scriptJ itself. o Directly express discretionary push
and pull concurrency o Functional and Logic Programming are integrated into
general concurrent programming.
The Actor model is a mathematical theory that treats "Actors" as the
universal primitives of concurrent digital computation. The model has been used
both as a framework for a theoretical understanding of concurrency, and as the
theoretical basis for several practical implementations of concurrent systems.
ActorScript is a general purpose programming language for implementing
massive local and nonlocal concurrency. It is differentiated from other
concurrent languages by the following: * Identifiers (names) in the language
are referentially transparent, i.e., in a given scope an identifier always
refers to the same thing. * Everything in the language is accomplished using
message passing including the very definition of ActorScript itself. * Binary
XML and JSON are fundamental, being used for structuring both data and
messages.
Organizations of Restricted Generality (ORGs) raise important issues for
formalizing norms that require extensions and revisions of previous
foundational work. For example, extension and revision is required of the
fundamental assumption of the Event Calculus:
Time-varying properties hold at particular time-points if they have been
initiated by an action at some earlier time-point, and not terminated by
another action in the meantime.
This paper develops a strongly paraconsistent formalism called Direct
Logic(TM) that incorporates the mathematics of Computer Science and allows
unstratified inference and reflection using mathematical induction for almost
all of classical logic to be used. Direct Logic allows mutual reflection among
the mutually chock full of inconsistencies code, documentation, and use cases
of large software systems thereby overcoming the limitations of the traditional
Tarskian framework of stratified metatheories.
Arguably, the original paradigm for computation was Logic Programming broadly
conceived as "deducing computational steps from existing information."
The idea has a long development that went through many twists in which
important questions turned out to have surprising answers, including the
following:
* How much of concurrent computation is reducible to deduction?
* Are the laws of thought consistent?
* Is "rapid recovery" a more viable policy than "inconsistency denial"?