Oh wow, thanks for this thread. Really glad to see all these ideas and links!
It calls me to share an overview of what I have been working on for the last year since leaving the Holochain core team (that is as an active full-time member).
The idea to get rid of siloed apps, or even the concept of apps in general has been fascinating me for the last 6 years or so, at least in an explicit way - in an unarticulated way even longer. It was what pulled me in with Holochain. I quickly realised that switching your thinking to be agent-centric holds an implicit offer to create an eco-system of “languages” (spoken by those agents) where data can easily be shared and remixed beyond (current) app boundaries (see my article from 3 years ago: Holochain: Reinventing Applications | by Nicolas Luck | Holochain | Medium).
With Holoscape I wanted to show a very rudimentary first step into this direction for hApp developers to start thinking outside of monolithic apps that use Holochain just as a back-end replacement.
Working with Junto (and in particular @josh) on realizing ideas described in that article, I came to an interesting insight:
- agents don’t only speak various languages (=DHTs/DNAs) with each other
- they also hold different Perspectives when doing so
- and meaning being contextual is held (even defined) by their very own/personal/subjective perspective, not really by the objective expression of a language (=entry of a DHT)
This led me to think, that the ontology underlying Holochain (1. agents and 2. languages/games/dances/DNAs/DHT) is a great start but incomplete. It leaves open exactly the questions being raised here. And a formal introduction of the concept of perspectives as a root ontological entity next to agents and languages is something worth trying.
So I spent the last year testing that idea
The result is a project I’m currently about to birth into its next stage: Perspect3vism · GitHub
The core piece of Perspect3vism is this (meta-) ontology of 3 root entities:
Ad4m is the only aspect of Perspect3vism that already has a website (the rest is being worked on right now): https://ad4m.dev.
The Ad4m repository above includes types and interfaces which serve as the smallest common denominator. Apps (here meaning UIs) can be build against the Ad4mClient and thus would be decoupled from languages (DNAs) and sit on top of an abstraction layer that enables mixing of expressions of different languages within perspectives.
There is an almost complete, but already well working and tested implementation of Ad4m, called the Ad4m-executor.
Coming from Holochain, you could see this as a super-conductor. Similar to Holoscape, it manages a Holochain conductor for you, such that languages can request to have a DNA installed easily (no need for the language developer to deal with configuring and setting up the conductor).
See for instance the language of languages here: language-persistence/index.ts at master · perspect3vism/language-persistence · GitHub
(which is Ad4m’s version of the hApp of hApps).
But Ad4m Languages are not confined to hApps/DNAs. Nothing in Ad4m/Perspect3vism is actually dependent on Holochain. Ad4m languages can use any kind of distributed or centralized storage technology for their implementation. The Ad4m executor also sets up an IPFS node next to the Holochain conductor. See for instance this simple Ad4m language that implements text notes stored and shared via IPFS: GitHub - perspect3vism/lang-note-ipfs: Ad4m Language using IPFS to store text notes
Ultimately, an Ad4m language is a JS module that exports a
create function which returns a Language object - implementing an interface. What happens inside the language (calling zome functions or doing HTTP requests) is completely up to the language)
Ad4m is a spanning layer decoupling semantics represented in perspectives from any kind of storage layer - so you can build apps mixing data stored in Holochain DHTs with transactions in blockchains, IPFS objects or centrally stored Tweets.
Perspectives … and Neighbourhoods
An Ad4m Perspective is just a set of links - that is triplets, i.e. links with predicates. In other words, a perspective is a graph over the expressions of languages.
Perspectives are the building blocks the ad4m implementation provides to sort and index data according to use-cases (not according to the tech used to implement any component of a use-case). UIs can make the ad4m-executor create new, emtpy perspectives like files. So a perspective can serve a specific use-case and encode associations between (objective) expressions (i.e. DHT entries) and thus build a complex graph that contextualizes data - very much akin to Semantic Web approaches.
Perspectives “are agent-centric”. Unless shared, perspectives are local only and fully and only controlled by the agent. They can be regarded as a scope for the user’s 2nd brain.
But perspectives can also be shared. Shared perspectives are called Neighbourhoods. (100% congruent with @sidsthalekar’s definition of a Neighbourhood “generic tech, specific culture” https://neighbourhoods.network/ - Sid and I have been talking periodically about these concepts for more than half a year now)
A Neighbourhood “entangles” several agents’ local perspectives with each other through a LinkLanguage (an ad4m language in which agents share links (the links that make up a perspective) with each other).
When sharing a perspective, a Neighbourhood expression (yes, in a language of Neighbourhoods: GitHub - perspect3vism/neighbourhood-language) gets created. That neighbourhood expression is what a user can share like an invite link (
neighbourhood://Qm23hbef23423...) to have other ad4m agents receive the neighbourhood description, which includes the URL/hash of the link language, which in turn can be received via the language of languages and used to entangle a local perspective with other’s perspectives.
Since Perspectives don’t constrain which kind of expressions can be linked, Neighbourhoods are pure social contexts as mentioned by @ViktorZaunders in this low code conversation:
There is a general-purpose UI that is still very alpha. It is meant to serve as a generic browser for Perspectives and Neighbourhoods - and as a way to really communicate what Ad4m and Perspect3vism is. (The lack of this app being usable is what kept me from sharing all of this more publicly so far… but we gotta start sometime )
Status and Outlook
- Above described workflow of sharing Neighbourhoods and joining them is working and part of ad4m-executor’s integration tests - including a link language built on Holochain
- Junto is being built on Ad4m which means that their groups and channels are Ad4m Neighbourhoods. Which means any other app/UI (like Perspect3ve) can work with these “social/collaborations contexts” and add other data in the form of links to new/other languages.
GitHub - juntofoundation/communities
- Ad4m and the Ad4m-executor have everything that is needed (as currently known) for Junto’s use-case
- Bootstrapping languages (language of agents, languages, perspectives, neighbourhoods) are implemented and working (using a mix of Holochain and IPFS).
- we’re in communication with several other projects and there is a common sense that this minimal abstraction of agents, languages and perspectives is powerful enough for all use-cases discovered so far (which is the main claim behind ad4m that needs testing and empirical backing)
- we just started hiring and assembling a team - looking for at least one more developer and potentially a UI/UX designer
You can talk to us and others looking into building on Ad4m in the Perspect3vism Discord: https://discord.gg/V9MfjpxB