Demo@50 | Doug Engelbart | The Demo | What Is Still Missing | What We Are Building | The Collaboration | Who We Are



Lorand Kedves


Consciousness | Thankfulness | Transparency | Simplicity | Evolution | Time


Who I am  I am Lorand Kedves, born in Hungary in 1973, graduated programmer since 1994, husband and father since 1998. I have been working for 20+ years as programmer, software architect and system analyst, but I had to realize that I use these words in completely different meaning than others. Today I say my profession is applied philosophy.


I was 15 when I spent a school holiday with 3D cube drawing. That was late 1980 in Hungary: no toolkits, no books, no internet; only strong will, lot of time, coordinate geometry, matrix operations and brain power against the first 4.77 MHz IBM XT at my father’s workplace, a Turbo C IDE and basic draw commands. When I copied the working result onto the school machine, I swapped the parameters and destroyed all my work in a split second. After 5 minutes of pain I have realized that the result of the previous 2 months was not a few pages of weird text that makes a machine rotate a cube on the screen but my ability to do that. In a few hours, I had the same(?) program again, but the lesson guides me since then.


The medium (platforms, tools, languages etc.) are necessary, but the essence is collecting and refining knowledge until a machine can execute what I have understood that far. Start talking only after having a working solution but be ready to trash it all if there is a better way. The “if it works, don’t fix it” approach is practical but gives no way for real improvement.


At the previous AI boom, I was lead developer at Cygron/Mindmaker (a data mining, AI, artificial agent “startup” with significant successes like winning Comdex 1999 Fall but collapsed at the dotcom crash); architect at national government projects and multinational companies, SW quality assurance engineer at Continental Automotive; technical leader or owner at startup companies.


I always felt contradiction between the concepts and practice of system development and programming, missed the transparency of a working system and the flexibility to reach and integrate new understandings. We create information systems to support flexible resource management in the outside world, but the same goals disappear in making those systems. My attempt to solve this problem was Dust Framework (now Platform), an environment that handles software components, structure and configuration with the same tools we use to handle the data within the application. In 2015, I returned to the university with the research topic “Software as Data Structure” that earned me MSc degree, and transformed to a broader “Dynamic Knowledge Representation”, the aim of my PhD study. At last in 2017, I have found the origins of informatics, and among others, Douglas Engelbart. I think this the solid background of my work.


My web or social media presence  I consider myself „intellectual” according to Noam Chomsky’s definition: as a system analyst, I looked beyond the technical level and learned a lot about climate and environment issues, sustainable economy or social systems. I appeared at public forums, searched cooperation opportunities with social aware people and groups, had a blog with 800+ posts, wrote 2 books, held lectures; both technical and “other” fields. In 2006, when I realized that my research may have some impact, I created a foundation to be the owner of all IP I may create and enforce “pro bono” utilization. This approach has taken a lot of effort with no results and caused continuous financial problems.


In 2017, I decided to start my PhD and stabilize our life, so I closed the foundation and all not-so-politically-correct public presence and got a fine government-related job. What remained can be found on LinkedIn (some technical and less technical posts), (that opens my second book on GitHub, where you can find a quite old brain dump of Dust, and soon the current Montru experiment), and more recently, on ResearchGate where I also plan to put some old articles of „intellectual type”.



What I am Doing  At the university, I am in serious debates about the current state of the art of informatics with my professors (who are mostly of the same age but have different background). For example, taking the scientific definition of information, if a system has a complete plan, then the specific information content of its source code is zero. The code only represents the knowledge about how the planned structures and behaviors can be implemented in the selected environment. It adds nothing to the system; therefore, it should not exist, or should be generated completely. I also demonstrated the serious gains that can be achieved if we avoid using the standard OOP approach (realizing that OOP and MVC paradigms are in direct opposition) in real life projects. One of them is my current full-time job.


With the help of this discussion, I have finally understood the essence of Dust Platform: it contains a scientifically closed and technically usable definition of “information”. I had a working knowledge manager: Dust Construct a few years ago, which I used to design itself (a Java application that generated part of its own source code). At the university I have found important results (Böhm-Jacopini theorem, P-Graph process representation) that helps me moving towards the absolute goal: an environment that can generate its own source code completely. Of course, it will wrap and use platform features, because it is not necessary to write a GUI framework or database server if it is available and can be integrated through a platform independent service layer.


I plan to build the new version of Construct: Montru (Esperanto word meaning “show it”). This is a generic information browser and editor over Dust Platform, the only tool necessary to access anything represented by Dust entities, which covers everything I can think of (based on my experience).


How it Relates to Doug's Work  The analyses I have read from Douglas Engelbart (and others) are in almost perfect match with my previous goals, experience and experiments. When I read Augmenting Human Intellect and then watched the demo, I was shocked by the similarities. When talking to my supervisor about my next research goals, I decided to build something for the 50th anniversary. And then I found this place… :-)


Dust is an optimal platform for a Dynamic Knowledge Repository (even though I called it Dynamic Knowledge Representation this far), while Montru is practically “NLS on steroids”, because it can use huge amount of services, experience and infrastructure, neither of which were available at the time NLS was created.



What aspect/features of the DKR I feel should be built


  1. Generic ontology management that allows defining the elements (types and services) of Domain Specific Languages (DSLs). This is “the language of symbols”.
  2. Create the DSL for representing information, so we can store our knowledge, starting with the ontology DSL within itself.
  3. Create the DSL that describes the runtime that allows storing and interacting with any information, using their ontology also available in the system.
  4. Create DSL for storing and retrieving information in an external persistent storage. This basically mean: read/write a text file (JSON first), EAV DB, and generate source code (now Java) to support safer coding.
  5. Based on concepts known from workflow management, create the DSL that can describe algorithms, so the knowledge of operations can be stored.
  6. Create the DSL for change: context into which information items are loaded, managed, saved, committed, pushed, like a version control system, this allows collaborative thinking over the existing knowledge.
  7. Create the DSL for integrating a runtime environment, so it allows us to execute external platform-level services, like database, GUI, collections etc.
  8. Create plain text DSL, for storing text information with language (both human and other languages like data storage: XML, JSON, or programming), encoding. Now we can have a human readable interaction with the system and among group members. This is the level of template engines, generating / parsing streams with chosen protocols.
  9. Annotated / structured text DSL, headings, lists, styles. Important: this is only the meta level, the rendering attach visual attributes to the annotated elements; this is how you can homogenize formatting from different sources or improve generated speech.
  10. Standard geometry DSL and layout (direct, tabular, flow) to arrange text and finally achieve what we want from a “good enough” text editor.
  11. DSL for GUI control elements to text with layout, to have user interface.
  12. Using the geometry DSL, we can create a virtual environment where people can interact with each other and any information available in the repository in direct collaboration.


What infrastructures and components I think will be required and I am working on  I work on Dust Platform, which is 1-4 currently from the above list, and an initial version of Montru, which is essential to design the listed components. First it will be a relatively simple Java application with a local database, but soon should become a server component deployed on the server.

The infrastructure list above is quite strong and complex, I can’t make it without proper augmentation, and I guess at least 30% wrong which I can only correct when they show up as implementation problems.

Connectors to external components, integration of different platforms are beyond my reach, the maximum is Java and a partial Objective C. I may use external script/template engine (MVEL) but not for long. I will not use a toolkit if it (1) breaks the single responsibility principle, (2) too hard to integrate compared to the service it offers or (3) overlaps Dust core features.


How I Hope to Integrate with a DKR or Contribute  This is my solution to a global, transparent and self-containing DKR, but I am very interested in other approaches either to integrate or switch to them in case they are better. On the other hand, this idea is a serious moonshot, there is no guarantee that it is viable or can be built until the demo. If any of the elements are interesting for another DKR solution, they can be used for Doug50 demo.


My scenario/walkthrough  Instead of a walkthrough, I have a few ideas that I think would make this demo as strong as the original:


  1. It should not be organized in a physical location, but in a virtual environment.
  2. We should be able to build clients for the major hardware platforms, some desktop OSes and mobile devices. This is a viewer showing them the virtual environment for knowledge manipulation, like Alan Kay’s Back to the Future of Software Development 4/23/2003
  3. We can’t assume that the audience will have sufficient preliminary knowledge about the history of computing, the great and forgotten achievements. However, we could have partners, like VPRI, who could add their presentations, even in the simple form of annotating their YouTube videos or creating short summaries for them with direct jump links.
  4. Attendees could register to the event as soon as we have clients to their preferred platform. They may use the environment to create their own data sheet, create interest groups, look around for friends and colleagues, peek into what we do in the environment.
  5. The demo should be a perfect presentation. We should plan it thoroughly, create the complete script – and play it without telling at the beginning that this is not an on-line event, but a recorded walkthrough. Furthermore, using the text DSLs and translate the text to various languages and text-to-speech engines, we can let user agents like Siri talk over the presentation using the preferred language of the user. After we have informed the audience that this is recorded, they will get the controls to stop, jump back etc. in the demo.
  6. We should allow them to interact with each other in the virtual environment during the demo, in private group chatrooms.


The demo could be about knowledge and programming, using the simple “hello, world” as an example.


If you want to do it in Java, you launch an IDE, create a text file with specific syntax etc. There are lots of things like what is a project, what is package, what are the access control keywords etc. that you don’t understand, just paste some text and hope it works. You get used to this “download something, cross fingers” approach, and that is devastating. True, almost all questions have been answered, and it is really exceptional that you would be the first one on the planet who should type code to do that specific task. But you should not forget the importance of thinking or understanding.


In Dust/Montru, you can look up the components you want to use, connect them in the right way to make them work, and you can use the same environment to look up everything: how they work, what they mean. There is no “external knowledge” here, and the very moment you understand how to interact with the system, you can start putting your knowledge into it, or interact with others’ knowledge.


Exactly how and why Vannevar Bush described this operation in As We May Think, the “constitution of informatics” article in 1945.


How I Prefer to Collaborate  As you see, I am completely obsessed with Dust / Montru. Although I can imagine better environments, currently I earn enough money yet go to sleep and wake up on Dust every night, which is for me a proven method of working this far beyond the limits of my actual knowledge. However, there is no guarantee that it can work at all, or I am able to make it work.


So, asking for resources at this point would be inappropriate. On the other hand, I would appreciate any review or discussion about the ideas and hopefully, the progress of Montru, which may at a point in time be a part of the Doug50 efforts.


Thank you.