HyperDoc is an information substrate that integrates software with traditional hypermedia. Narratives can explain software, by referring to and transcluding source code. Source code can refer to documentation and examples. Diagrams can refer to the code or data they document, but also to the code that implements them. Small tailor-made software tools allow interacting with data, but also serve as documentation for how to work with that data.

Applying it to the design of the web we aim to create a system where we can do everything offline and in local networks and the connection to the internet is optional. This will help the neuronal groups be more resilient and fast. We invite others to join as co-creators to build a local first version of the Internet together.

The problem is that the modern Internet relies strongly on cloud technologies, where client applications communicate with each other only via servers. It is akin to having a server between any two neurons in the nervous system, or each neuron being inside a box that decides if the signal from this neuron can go through.

We’re bringing a social experience to Anytype by making spaces more interactive. We start with the concept of one space = one group = one chat. Then we’ll expand to include discussions on objects, enabling forum-like use cases. It will significantly improve collaborative use cases. You’ll chat and discuss your pages and files in the same end-to-end encrypted and local-first way.

We saw block-based editors as the future, not just for productivity but for social interactions. We centered Anytype on unique and extendable primitives: objects, types and relations. Why couldn’t a page be a blog post, a forum thread or some other object? Why not connect everything in a unified graph database, viewable as sets and collections? We were thrilled with the possibilities, though the complexity was immense.

Why examples? What are example methods good for? As we have seen, examples make dependencies between tests explicit by reusing examples as setups for other examples, thus forming a hierarchy of examples. Best practice in test design supposedly should avoid dependencies between tests, but studies have shown that this practice instead leads to implicit dependencies due to duplicated code in test setups. This in turn leads to cascading failures due to the same setups being repeated in numerous tests. By factoring out the commonalities as examples, the duplication is removed, and cascading failures are avoided. A further benefit is that examples can be used in live documentation, and, as we shall see, examples support an exploratory approach to test-driven development, that we call example-driven development, or EDD.

Start from an object Instead of starting by imagining and writing a test case as an example method, we start by creating an instance of the class we need. We first simply ask how we want to create our concrete instance of a price, and we write that code in a snippet. Neither the class nor the constructor exist, so we create them as fixit operations.

With TDD, you develop code by incrementally adding a test for a new feature, which fails. Then you write the “simplest code” that passes the new test. You add new tests, refactoring as needed, until you have fully covered everything that the new feature should fulfil, as specified by the tests. But: Where do tests come from? When you write a test, you actually have to “guess first” to imagine what objects to create, exercise and test. How do we write the simplest code that passes? A test that fails gives you a debugger context, but then you have to go somewhere else to add some new classes and methods. What use is a green test? Green tests can be used to detect regressions, but otherwise they don't help you much to create new tests or explore the running system. With Example-Driven Development we try to answer these questions.

Simply stated, Luhmann’s Zettelkasten structure was not dynamic or fluid in nature. Yet, it was not rigid, either. Examples of a rigid structure are classification systems like the Dewey Decimal Classification System or Paul Otlet’s massive notecard world museum known as, The Mundaneum. These types of systems are helpful for interpersonal knowledge systems; however, they’re not illustrative of what Niklas Luhmann’s system was: an intrapersonal communication system. Luhmann’s notebox system was not logically and neatly organized to allow for the convenience of the public to access. Nor was it meant to be. It seemed chaotic to those who perused its contents other than its creator, Niklas Luhmann.

Take Wikis as an example. Most of them have two different modes: The reading mode. The editing mode. The reading mode is the default. But most of the time you should create, edit and re-edit the content. This default, this separation of reading and editing, is a small but significant barrier on producing content. You will behave differently. This is one reason I don’t like wikis for knowledge work. They are clumsy and work better for different purposes.