
In the Beginning - ohgreatwtf
See first comment
======
ohgreatwtf
In the header files, SYSTEM declared the sys.io and the file.io library. Now
the object class was declared void, it had no content, the whitespace was
endless hovering over the status bar, and the text entry caret of SYSTEM was
positioned between the curly brackets.

And SYSTEM said, let there be function, and there was main(). SYSTEM saw that
the function was good, and he inserted curly brackets. SYSTEM called the
internals dynamic, and he called the externals static. And there was a file
save, and a program compile- the first revision.

And SYSTEM said, let there be a heap within the stack , to separate the
dynamic from the static. So SYSTEM made the heap and established the memory
bounds for the function from the stack of system available memory. And it was
so. SYSTEM called the heap protected mode. And there was a file save, and a
program compile- the second revision.

And SYSTEM said, let the addresses within the protected mode be gathered to
one place, and let a virtual address space be declared. And it was so. SYSTEM
called the address space executable and the gathered memory he called free
memory. And SYSTEM saw that it was good.

Then SYSTEM said, let the executable be initialized with data: number-bearing
arrays and objects that bear arrays with chars and variable-width data in
them, according to their various types. And it was so. The executable memory
was initialized with data: arrays bearing simple data types and objects
bearing arrays with data types configured to form complex data structures,
according to their kinds. And SYSTEM saw that it was good. And there was a
file save, and a program compile- the third revision.

And SYSTEM said, let there be addresses in the un-used area of protected
memory to serve as delimiters on addressable memory space, and let them serve
as the interrupt vector table, to mark sacred entry points, timing, and
hardware mapping, and let them be entry points into the program to give
hardware data to the program. And it was so. SYSTEM made two great interrupt
vector tables- the greater to serve as data access protection, and the lesser
to serve as hardware memory pages. He also made the entry points into the
program memory region. SYSTEM established them in the first pages of protected
memory to give entry into the program, to delimit the address space and system
memory, and to seperate the functional from the static. And SYSTEM saw that it
was good. And there was a file save, and a file compile-the fourth revision.

And SYSTEM said, let the executable memory be filled with functions, and let
message passing functions move data around the executive memory across the
protected memory space. So SYSTEM created the great functions of the executive
space and every piece of functional code with which the line endings roll and
that are seen defined here and there in it, according to their types, and
every message passing mechanism according to its kind. And SYSTEM saw that it
was good. SYSTEM blessed them and said Be fruitful and increase in forks and
fill the free memory with loops, and let the interrupt handlings increase in
the protected memory space. And there was a file save, and a program compile,
the fifth revision.

And SYSTEM said, let the executable contain managed assembly libraries
according to their types: the database engines, the framework which is found
through the executable space, and the garbage collection runtimes, each
according to its kind. SYSTEM made the garbage collection runtimes according
to their kind, the databases according to their kind, and all of the
frameworks. And SYSTEM saw that it was good.

Then SYSTEM said, let us make operating systems in our nature, according to
the design which we are made, so that they may rule over the code running in
free memory, over the message handling bus, over the databases and all the
garbage management runtimes, and over all the frameworks which are used in the
executive.

So the SYSTEM created OS in his own image, in the image of SYSTEM he made
them, embedded systems and mainframes he created them.

SYSTEM blessed them and said to them, be fruitful and increase in number, fill
the protected mode and subdue it. Rule over the free memory and the code
running in protected memory and over every piece of code in the executive
space.

Then SYSTEM said- I give you every data structure in the executive and every
object that has arrays with data in it. They will be yours to consume. And to
all the garbage collection runtimes and to all the bus runtimes and all the
frameworks- everything that has a function definition-- I give every piece of
data not in an object. And it was so.

SYSTEM saw all that he had made, and it was very good. And there was a file
save, and a program compile- the sixth revision.

Thus the system memory and the protected memory area were completed in all
their vastly detailed ways.

By the seventh revision SYSTEM had finished the work he had been doing, so at
the seventh revision he saved the files and closed the IDE. Then SYSTEM
cryptographically signed the seventh revision and uploaded it, because on it
he closed his IDE and ceased from all the work of coding on it that he had
done.

