In a nutshell

Our fundamental concepts, tools and platforms in which we design and implement information systems prevent us from making them flexible and “organic”. They tie us to their components and versions, hide the structures in huge text files, get more rigid and fragile by every change. To step forward, address the true living and evolving nature of every system, we need a radically new approach. This would be important before start solving any particular task, but essential in mitigating critical situations like the Corona crisis.

My take on this task is the MiND project. In this short summary, I focus on the technical part, with some hints to theoretical and external connections.

Why have I registered this hard-core technical project to the Social & political cohesion | Developing people-driven economies channel?

Because we try to build information systems to help in this situation. All of them are both empowered and limited by the infrastructure they are built upon. If there are fundamental errors in that layer, they will inevitably cripple even the best efforts. Douglas Engelbart, the founding father of today's IT world demonstrated this statement in a simple experiment. He predicted the fundamental social change that would be caused by the exponential growth of IT capacity (part of this statement became the famous Moore's Law) and wanted to focus on the benefits: Augmenting Human Intellect and Boosting Collective IQ.

On the other end, we must keep our human values, understand the importance of cooperation between the human and the artificial side, ask the important questions and consider the possible side effects instead of a total surrender to the technology. This opinion was delivered by another giant, Neil Postman. This is why a technology that promises further boost to the power of information systems, must appear and be under strong social and political control.

If you are interested, you can look for other favorite Unsung Heroes of Informatics. But if only some people now learned the name of Engelbart and Postman and got interested in their work, it was already worth the effort.

Thank you.


I started coding 35 years ago, have been designing and writing complex information systems for 20. My focus had always been on the relationship between my knowledge: what do I know about

  • the external process or organization that my system will support,
  • the tools, programming languages, platforms that I use,
  • the technical environment,
  • the human environment: users, managers, colleagues.

How can I participate or lead a way from rough ideas to a working system? How can I manage the changes in my knowledge, in the requirements, in the environment at the initial prototyping phases, in a working development version, or in a deployed active system?

The experience brought interesting conclusions. A good structure eliminates big amount of otherwise necessary code, but overthinking and misplaced boundaries are the worst nightmare. Although it depends on the actual task, but most of the system is “housekeeping” (serialization, communication, user interface, validation, …). The genuine part of any information system is surprisingly low, and in most cases that still a replication of many other already existing systems. The knowledge does not depend on the programming language, the data structures and algorithms are almost identical in any environment. However, each line of code is a possible error, and the knowledge “freezes into” the code. The further you go with the implementation, the less likely that you can integrate new understanding into the system.

This is relevant here because the mentioned problems already plague any information system both at development and support, even in perfectly normal conditions. We all know examples of incompatible libraries, changing and breaking platforms, forever-living Cobol systems. In a situation like the Corona crisis, these problems all add up. The data structures and algorithms change all the time; the operation must be reliable and transparent; and we still would like to keep proper privacy and responsibility over all the sensitive data. This is not the situation to run fast and break things, rather one that may teach us to respond instead of react. See Why Fighter Pilots know that Quick Reactions are for Losers.

What it does

MiND (acronym for Model, Idea, Narrative, Dialog) is the result of a decade-long journey, born as DUST (Distributed Unit System Technology), became “Dynamic Knowledge Representation” at the beginning of my PhD research, and ended as “Augmented Learning” or a form of Artificial General Intelligence. It is an environment that allows designing, implementing and executing an information system at the same time. Its data structures are runtime configurable: you define your data types, attributes and relations, and can edit and work with them immediately. When ready, it can be the center of any information system, in any language and platform. It is similar but beyond the Neumann Architecture which is the core of all algorithm execution hardware.

The system consists of three fundamental components.

  • MiND is a “language of any knowledge”. It naturally contains its own description (like a C compiler written in C, or the EBNF definition of the EBNF language syntax). You can use MiND elements the same way as you use a programming language to describe your data structures as “classes” and algorithms as code blocks. However, as MiND is part of this ecosystem, your newly created elements are immediately active and usable, without compilation, deployment etc.
  • DUST is still part of the environment, it is a reference implementation of a runtime that can store data and execute algorithms described using the MiND “language”. Important notes: your MiND description is independent from DUST, you can have other implementations if you like; but DUST also hides the actual running platform and programming languages. The required sources are generated from the MiND descriptions.
  • Montru (Esperanto word for “show it”) is a user interface where you can interact with literally anything in the underlying DUST / MiND layers. You can think of it like an SQL console on a database that allows you to access all functions and all the data in your database. Montru allows you to interact with the network of the knowledge you have in your system, or extend without limitations, compilation, deployment etc.

So, what it does? It is like the database under any information system that allows you to reliably store, read and change any data that you want to manage. MiND allows you to build all the data structures, algorithms, user interfaces, network interactions, … on any platform you have a DUST implementation.

How I built it

The concepts are results of previous information systems that I have created in C++, Objective C, Java, C#, JavaScript. The last development process started in February 2019, behind a smart vehicle fleet management R&D project. The first version is a quite elaborate Java implementation with interactive knowledge graph editor, source code generators for Java, C# and C++, HTTP/JSON interaction and serialization, prototype database connection. The current branch is in C++, targeting the last unknown area: the complete algorithm definition and execution code generation. The previous Java version was abandoned because it was not able to generate its own code and changing the initial prototype decisions would have too many risks.

Challenges I ran into

The greatest problem is that I do not know the solution when I start working on an area. I must create a POC (proof of concept) level but fully working implementation to realize where I was wrong. Then I must be able to take the working component apart to fix it. And repeat this process all the time.

It takes a long time to find the right approach and architecture. Smaller projects do not allow such flexibility, so most of the solutions came from multi-year internal developments at the government or multinational companies.

At the current phase, I must minimize my dependency on any feature the actual platform provides, because 1: I must implement the same operation in other languages the same way, and 2: I need to see how the whole code would look in MiND entity network and how it will be generated. I must “emulate” an even not fully planned automatic behavior in my painfully limited human brain.

Finally, it is hard to explain what and why I do. I think I am in a kind of information singularity; it is easier for me to write a working component than talking about them…

Accomplishments that I'm proud of

Some quite large information systems I was lucky to design and implement; and the lessons I have learned from them.

The fundamental concept that the information system’s structure and the data it manages can and should be described with the same “language”.

The Entity / Type / Service concept that allows breaking the limitations of Object-Oriented Programming; and that I did not have to change this concept for at least five years. Until now…

The fact that during my PhD research, I have “met” the greatest masters of information science (like Alan Kay, Douglas Engelbart, JCR Licklider or Vannevar Bush) and beyond towards our general relation with knowledge (like Ted Nelson, Noam Chomsky or Neil Postman), and concepts like Tensegrity from Buckminster Fuller. And I have found that their results resonate with what I tried to achieve.

What I learned

I have learned a lot about intelligence in general, and its practical representation in a computer. I know something about its relation to our civilization, both the advantages and the unwanted side effects from individual “inverse vandalism” (Alan Kay) to the Technopoly (Neil Postman).

What's next for MiND

  • The technical task is straightforward: invent the self-containing algorithm language, code generation, and thus design and generate the source code of the DUST runtime. Then continue with the Montru interface and core modules. This is quite hard but depends only on me.
  • The more complicated task is to find partners and a proper “safe” environment for this project. I am confident that a much better future can be initiated by using the fraction of the budget of a next Hollywood movie about it. I belong to the lucky people who can support this bold statement with real life examples, like the Sketchpad from Ivan Sutherland, the Mother of All Demos from Douglas Engelbart, or the Dynabook from Alan Kay. I wish this list would be more popular and continue with new items...
  • Finally, I want to find ways to cooperate with real-life projects, to support solving actual problems. I am confident that any information system will benefit from using MiND, and in short time we will be able to develop a powerful suit of modules that will allow even faster and more reliable systems of this family.

I would like to close with a favorite quote of mine from the Libraries of the Future, JCR Licklider, 1964.

„… the “system” of man’s development and use of knowledge is regenerative. If a strong effort is made to improve that system, then the early results will facilitate subsequent phases of the effort, and so on, progressively, in an exponential crescendo.”

I think MiND could be part of that process.




  • Montru on GitHub: You find the projects used in the previous Java prototype shown in the demo. It has features like the designer GUI, source code generation for C# or C++ runtime, JSON-based serialization and HTTP interaction with other instances. Abandoned for newer, less mature version.
  • DPL on GitHub: The current ongoing development with a cleaner architecture, in C++.
  • "Personal research blog" on Medium: I log my progress, sometimes write things here.

Other materials

Share this project: