Underscore protocol (_prtcl) puts together the core ideas behind the World Wide Web, Git and Linked-Data in creating the concept of Evolving Entities ("Evees"). This is an effort that falls under the category of what is known as ontology engineering (conceptual modeling and knowledge representation on the web) and things like the Semantic Web and its goal of making Internet data machine-readable (with its RDF — Resource Description Framework, where the aforementioned idea of Linked-Data comes from and that Tim Berners-Lee's latest Solid project also builds around). Other more recent and conceptually related projects are idyll (a markup language and a toolkit for creating data-driven stories and explorable explanations), Holochain (with things such as Semtrex, a kind of regex, but handling meaning, as a semantic tree expression evaluator), Berners-Lee's just mentioned Solid and perhaps others.
An Evee is basically a useful/re-usable/re-purposable and platform-agnostic object that:
- Like URLs on the web, it can be linked with other Evees on a range of other apps across any platform.
- Similar to Git repositories, it can have multiple different perspectives and contexts (forks, modifications and/or mutations).
- Like Linked-Data, can be re-used, re-purposed, rendered and interacted with on a wide range of different apps and platforms/environments.
Web apps usually consist of a front-end user interface and its application logic in the back-end service it connects to. Users interact with the front-end by creating, interacting with and consuming data objects which are otherwise read, written and stored from entries in a back-end database. _Prtcl provides a way/possibility to link, render, (cross-)reference and interact with data objects of any application from any other application (similar to what early Web users had with the simplicity of HTML documents and URLs). To accomplish this, front-end applications and back-end services should introduce support for handling and rendering Evees (Evolving Entities) instead of transient data objects. _Prtcl builds from a few basic components: Evees, the Cortex Framework, and Service Providers.
Evees: Evolving Entities
Evees behave similarly to Git repositories, but instead of sets of folders and files contain JSON objects. They evolve as sequences of content-addressable commits which may fork at some given commit to bifurcate and create more than one head — each head of the sequence referred to as "Perspective of the Evee". So, what _Prtcl proposes/implies is that instead of working with objects, applications should rather work with Perspectives of Evees.
Perspectives are important in that they allow the independent co-existence of parallel versions of an object, in place of forcing all applications and users of an object to interact with the same version in stepping on each other. They afford freedom and divergence while organically facilitating agreements and convergence.
A diagram of an Evee, evolving as a sequence of commits and going from having one perspective (zbP1) to having two (zbP1 and zbP2).
Cortex Framework: Specifying Front-end Functionalities Around Entities (Evees, Data Objects and Structures)
Web apps and their back-ends tend to be tightly coupled with the data structure of the objects they handle and manipulate, failing at addressing any other type of objects — which is one hurdle preventing Evees from being as universally interoperable among different apps. Developing applications that can dynamically render and manipulate objects with different data structures should be achieved without forcing strong constraints and restrictions on developers about the types of data and operations they can perform in their apps. And this is what Cortex Framework is meant to do as a generic framework for specifying front-end functionalities around Entities (data objects):
- One-object-multiple-apps (OOMA): One type of object is rendered and manipulated in different applications.
- One-app-multiple-objects (OAMO): One application is able to render and manipulate objects of different types.
Cortex is built around the concept of patterns: a dynamic typing system that associates certain behaviors to entities fulfilling a given condition on its data structure or value.
For learning more about Cortex in more depth and detail, see the js-uprtcl documentation.
Service Providers: Interoperability Between Platforms, Protocols and Networks
The following Evees Service Providers are being currently developed:
- js-uprtcl: Includes a Local Service Provider, using the native browser indexedDB to store Evees.
- eth-uprtcl: Store and govern Evees in Ethereum and IPFS.
- js-uprtcl-server: Store and protect access to Evees in a Node.JS web REST API.
- hc-uprtcl: Store, govern and protect access to Evees in Holochain.
_Prtcl Re-usable Modules
A set of open-source _Prtcl Cortex modules is also being developed. These modules will soon be released and will include web-components, state-management, patterns, and service providers to let developers integrate _Prtcl functionalities on their apps in a matter of minutes.
This is a list of the web-components from the modules that (will soon be) available:
- GenericPost: Bundles of text and images, similar to a Tweet or a Facebook post.
- SimpleEditor: Simple editor to write blog-posts or documents that can scale.
- KanbanBoard: Kanban board to organize cards in columns.
- Calendar: Calendar board to crate and display events.
- Drawer: A drawer to organize and store Evees.
A minimum viable user experience demo of _prtcl. The technology reminiscent of things like, for example, William S. Burroughs' cut-up method, or how Chinese is thought and written, etc., etc. It's apparent how such a thing could be mighty useful for states such as writer's block, for instance. Or in inter-disciplinary research and in various areas and fields to do with the so-called digital humanities (more on that soon in future posts and articles). Unsurprisingly, it is also meant to integrate with Holochain, with which it does share quite a bit conceptually.