 18 Sep 2016 @ 00:32, by Max Sandor
by Max Sandor
Title
The ConCur Paradigm - the structure of Reality
Short Description
A basic model for the simulation of reality and its abstractions thereof as performed in computing processes on both hardware and software level,
Synopsis
A basic model for the simulation of reality and its abstractions thereof as performed in computing processes on both hardware and software level,
Keywords
Reality simulation, failsafe programming, self-writing code, self-design of robotic systems, bootstrap algorithms, Turing machines, minimal systems, self-correcting robots, recursive algorithms, language design
History
- Conceptionalized in 1976 as a minimum compiler-compiler (a computer program that creates its own syntax rules) while developing a Meta-Parser (a universal code sequence that defines tokens for any possible language) at the Technical University Darmstadt, Germany
- expanded in 1981 for use in hardware design using bit-slice technology
- reframed in the 1980s for use as a simulator for any thinkable reality and submitted as a dissertation at Pacific Western University at Los Angeles in 1990
- introduced to a wider public in 1991 at the IEEE 4th World Conference on Robotics Research, Carnegie-Mellon University, Pittsburgh, and published in its proceedings.
Purpose and Scope
To replace current computer software and/or hardware systems with fail-safe, self-generating, and self-optimizing code programming and hardware layers.
Concept
"Reality" can be defined as the interpretation of perceptions. Perception is based on the observation of a difference in a signal. A signal difference always yields a polarity. With these elements alone, a machine can be devised which represents reality completely and error-free at any given level of resolution.
In simple words
EveryTHING can be divided into two parts with qualities that could be called yin and yang, female and male, and so forth. Repeatedly doing so will give us a structure called a 'binary tree'. If done correctly it will be a complete and exhaustive description of the THING. The quality of this description depends on how many levels deep the division into yin and yang has been done. It can go from galaxies to molecular structures and is called the 'resolution' of the model. Applying this approach, we can create computers and computer programs that are so close to reality that we could not know which is which from within the system itself. It is postulated that such computing structures use minimal resources and yield maximal speed, safety, and flexibility. The aim is to replace today's complex computer machinery with ConCur based automata.
Features
In contrast to common 'reality',
- a ConCur program can simulate itself
- ConCur 'code' can be run recursively (fractal proposition) to controllable depths
- it doesn't matter what portions of a ConCur program are implemented by hardware or by software
- such hardware and software segments are 'hot-swappable' (no boot or restart)
- ConCur segments can clone themselves, creating 'remote agents'
- self-modification is possible through creating simulation within simulations which are controlled by 'supervisor agents'
- ConCur code can self-optimize by evaluating simulations within simulations (through supervisor agents)
- ConCur code can 'modulize' itself, that means it can shell out code segments to create re-usable moduls, resulting in minimal hardware and software storage requirements.
Advantages
- failsafe operation modes
- self-optimizing programming
- minimal models for simulating reality
- universal models for languaging (cross translating abilities)
- a step towards a more effective and applicable 'artificial intelligence'
Challenges
- the main feat for programmers is generally the switch from sequential to structured thinking and coding. ConCur strictly enforces the principles of Object-Oriented Programming. Most of today's OOP applications can be used in a mixed-mode. Few programmers exist who are truly comfortable in OOP-only-environment.
- a further challenge is the need to separate polar units into their positive (yang) and negative (yin) aspects, While trivial when dividing a computer into hardware and software, for example, other items may require a quite profound understanding of the concepts at hand.
Basic Design
ConCur implementations are binary trees for BOTH program and data. There is NO structural difference between both because program and data are just part of the giant ConCur tree of the entire Universe. ConCur defines itself using its own paradigm, ConCur.
More descriptively, what we call a 'program' we associate with a positive, active, 'yang' quality; 'data', as a phenomenon, accordingly as a negative, passive, 'yin' manifestation.
A 'program' part can be either actions, such as commands, which is active, yang, positive, and queries or branching which is 'yin', its negative side.
A 'data' part can be fixed (yang), such as constants, or variable (yin) which are containers.
If we go upstream in this ConCur model, we arrive at the concept of software, which is the 'yin' part of an 'agent. Obviously, the 'active side' is the hardware (yang). An example for an agent consisting of a mechanical device would be computer, or more complete, a robot. For the 'life forms' of a human as such an 'agent', we would have the physical body and the 'mind'.
If we go downstream in the model, we'll arrive at 0/1 on the computational level and a /- charge in the physical media.
In short, a systematic progressive split into yin/yang sides will give us a conCur representation of a 'reality'.
Reality and Language
'Reality', as defined like above, and 'Language' as such are interchangeable phenomena. Any ConCur representation can therefore also be used as a language. For an example of a self-defining language created with these principles, see 'Genesis of NeuLinge' [2].
Implementation
A rudimentary ConCur implementation is a collection of token pairs. In its most basic form:
[State Id] [action returning a perception/evaluation] [pointer if positive] [pointer if negative]
In a minimal. simulatable, and failsafe executional form:
[Time] [State Id] [action returning a perception/evaluation] [next State if positive] [next State if negative] [error escape]
For practical applications, a context must be chosen. This is the 'data' side of the implementation. Both streams can be mixed and can be recursively defined or invoked.
Developed applications
For business reasons, the existing ConCur applications focused mainly on a few marketable areas such as language translators and trade transaction simulations:
- 1988: Digipak, an interface between CAD and dimensional inspection robots, implemented in Pascal and XLISP
- 1989: The Hole - a BBS role-playing game with minimal data exchange flows, implemented in LISP
- 1993: NOPS, a Universal stock and option trading strategy platform, which was used to simulate all major trading strategies at the time for all the data of the Futures and Options of CBOT (Chicago Board of Trade) since the year 1898. implement in Visual Basic
- 1995: GeoTrans, a programmable cross-translator for DMIS and other dimensional inspection languages; implemented in Pascal.
Similar application concepts
The Block-chain principle [3] as used by Bitcoin is an example of a ConCur model that is using 'remote agents' and implements 'supervisor agents' to describe payment transactions that can exist independently of a centralized data collection authority.
Similar concepts in philosophy and science
The cognitive scientist Donald Hoffman uses evolutionary game theory to investigate our perceptions of an independent reality. All arguments presented at [4] dove-tail into the ConCur paradigm as a relevant model for a representation of reality at large.
Vision and Outlook
Everything that exists can be represented by a ConCur model using an appropriate resolution of the digital data. In this aspect, ConCur can be thought of as a perfect Turing machine. It can be used for both software and hardware aspects. The extreme simplicity of its binary structure invites the vision of using it in both biological computers and of quantum-state computers.
To a certain degree, ConCur representations are fully scaleable and can be mixed with current solutions. A gradient global implementation path would be realizable.
It could be speculated that research and development in computing would eventually go this way in any case because it is the most effective, close-to-nature solution available and thinkable.
The first 25 years since its publication has already shown several indepedent technological movements in the direction of the postulates of the ConCur Paradigm and more are sure to follow soon.
References
[1] IEEE 4th World Conference on Robotics Research, 1991, Carnegie-Mellon University, "ConCur - a Computing Paradigm"
https://openlibrary.org/books/OL13300409M/4th_World_Conference_on_Robotics_Research_1991_1898
[2] Genesis of a language
[link]
[3] Blockchain principles
https://en.wikipedia.org/wiki/Blockchain_(database)
[4] The Evolutionary Argument Against Reality
https://www.quantamagazine.org/20160421-the-evolutionary-argument-against-reality
-----------
Max Sandor on the web: maxsandor.com
Amazon's author page: Maximilian-Sandor
Facebook (Public Figure Page) MaximilianSandor
|
|
