Editorial note - I was thinking a bit this morning and realized that we should try to cover some additional topics which probably fit best in this report right now. I’ll summarize each topic in a separate post. First: applications!
Applications
Prose definition
Applications consist of related resource logics, which define the kinds of resource which constitute the application’s state, and transaction functions, which define the actions users can take to interact with the application. The abstraction of an application is virtual - applications are not deployed or tracked in any sort of global registry - rather, they are content-addressed by the specific logics involved. An application can be said to exist by virtue of the existence of resources referencing these logics, and if these resources are completely consumed it no longer exists (except in history). Applications are also composable, in that the delineation of which resource logics constitute one application versus another is a choice made by the user, and that state transitions for multiple applications can be combined (atomically, if desired).
Formal definition
An application logic is defined as a set of resource logics:
ApplicationLogic := Set(ResourceLogic)
Application logics may be composed simply by taking the union of the logic sets:
compose(al1: ApplicationLogic, al2: ApplicationLogic) = al1 \cup al2
An application interface is defined as a set of transaction functions:
ApplicationInterface := Set(TransactionFunction)
Application interfaces may be composed in the default manner simply by taking the union:
compose(ai1: ApplicationInterface, ai2: ApplicationInterface) = ai1 \cup ai2
An application is defined as the conjunction of an application logic and an application interface:
Application := (ApplicationLogic, ApplicationInterface)
In order to be a valid application, all transaction functions in the application interface must refer only to resource logics in the application logic.
valid(a : Application) = scopeCheck(a.interface, a.logic)
Applications may be composed in the default manner simply by composing their components:
Application composition may also open up new, non-trivial interface possibilities on a per-instance basis.
Report integration
All of the examples we describe should instantiate this Application type (often trivially, e.g. with only one resource logic and only one transaction function), and we should describe some example compositions.