tl;dr

I'm building a from-scratch computing environment to explore the ideas of /coalescence through a technological lens. That effort has its own website.

Overview

During my exploration and meditation on /coalescence, I've found that a lot of the principles can be directly applied to computing. It's not surprising to me, because the nature of coalescence is deeply concerned with the line between the concrete and abstract, the nature of consciousness and cognition, and the (meta)physical properties of matter and information, all of which sit directly next to the field of computer science—in my opinion.

The core technical foundation of the coalescent computer is that data is the fundamental primitive, data is self-describing, and data has a deterministic canonical representation. This means that any two pieces of data that are semantically equivalent will always have the same canonical representation. This—in a mathematical sense—massively reduces the possibility space of data objects by eliminating the concept of permutation, though the possibility space is still infinite. Since data is the fundamental primitive, all code (or "routines") is also represented as data and has the same properties.

The fact that the data is self-describing combined with the elimination of permutation makes a content-addressable data system much more powerful. As an example: if we had a UI widget that expects data of a certain schema for display, we could attempt to feed in any arbitrary data, query our local system (or even the network) for any routines that transform from the source schema to the target schema, transform the data, and pass it into the UI—all automatically, if desired.

Anyone could define as many arbitrary schemas as they like, and still interoperate with any other people or tools as long as they write translation routines against common interface schemas. And since the schemas themselves have a deterministic structure, you easily eliminiate the most common points of conflict between similar schema definitions. Within the coalescent computing environment, someone defining a schema Vector(x: int, y: int) would coalesce to the same schema hash as someone defining a schema Point2D(y: int, x: int).

All of these pieces together showcase the core of the coalescent computer, and demonstrate its namesake. People are free to fork and experiment and diverge their computing environment to solve problems and meet their needs, but the best schemas and routines will proliferate, and the long tail of diverse implementations can still coalesce relateively effortlessly.

The actual "thing that I am building" is a from-scratch computing environment designed against these principles. It is a research project composed of a virtual instruction set, a programming language, and a data model specification, and will result in a real, usable computing environment. My plan is for it to be my personal and community /permacomputing environment for the rest of my life, but I have a hunch that it will be useful for many others, with a small chance at being used very widely.

Further Reading

For more detailed reading, the Coalescent Computer project website is the best place to dive into specifics. The page/website you are on now will be updated as the project gets closer to maturity, but the active development and in-progress documentation will live on the dedicated project site in the mean time.

• Coalescent Data (CODA) Specification
• Coalescent Database (CDB)
• Co Programming Language
• Coalescent Instruction Set (COINS)
• Cohost Virtual Machine