{C} revolution
C is the language of machines.
There is a C compiler for almost any Instruction Set Architecture.
C is similar to the lowest common denominator for machine languages.
The difference is that the lowest common denominator for natural numbers is a natural number.
So, runtime environments like JVM and CLR can be considered the lowest common denominator for Instruction Set Architectures.
The only problem is they are situated quite high on top of operating systems.
We mainly have three types of them, accordingly, runtime environments have many implementations and have complexities to handle.
In reality, we don’t have the lowest common denominator for Instruction Set Architectures.
In this article, we will discover how to advance CPU machinery to the next level.
It becomes easier once we focus on the most abstract form of computation, which is present at the end of any instruction.
The role of this computation is to use the execution context to determine the next member of the sentence, decode it, and find the instruction opcode, possibly with immediate data, to start executing it.
This is the core, Pith, of CPU machinery.
We can elevate and develop this computation for the next level to create a Sophisticated Central Processing Unit (SCPU) and a Sophisticated Instruction Set Architecture (SISA).
C code below:
This truth was always before us, hidden in plain sight.
It took me over a decade to revolutionize my understanding of computational paradigms and grasp the profound implications of this simple fact.
All programming paradigms we have can boil down to the “return value-oriented composition”.
Here we are introducing the “goto next word oriented composition” paradigm.
This is the path to evolving languages (SISAs).
This is the key to establishing the lowest common denominator for Instruction Set Architectures.
This is how we build layered operating systems, each identified and trusted by its unique hash codes.
This is how multitasking is solved.
This is the way to create trusted execution environments.
Moreover, we can implement pluralized execution contexts and pluralized sophisticated instructions.
This marks a new beginning. Hello goTo:
goTo is an elevated version of the most abstract form of computation.
This computation will be the final step of each sophisticated instruction.
In our program we have sophi_o, sophi_s and halt sophisticated instructions.
Next, we have an elevated execution context present in the registers.
In rdi, we have a base pointer for elevated text space (i.e., elevated memory), and in rsi, we have an offset of the text index (i.e., program counter).
goTo will be the first and only call instruction that starts the execution of the elevated execution context, i.e., the sophisticated program.
Note: The elevated execution context is present within the execution context itself.
In other words, we don’t need a context switch to continue execution in the so-called kernel or user space.
We have found an architecture for operating systems that are fractal in nature.
So, in goTo, we increment the text index, take the operation code from the new member of the sentence, and direct the execution flow to the corresponding sophisticated instruction using the lookup table for opcodes.
For simplicity, in the current SISA, goTo is defined for one-byte-long members of the sentence and can contain only sophisticated opcode.
In line 17, we have a program written with sophisticated opcodes.
Can you guess the output?
P.S.