Loper OS

I feel obligated to remind my readers that the Loper repository does not yet contain a working operating system. (Unless you count a boot loader which performs basic x86-64 hardware initializations and prints “Hello World” as one.)

The “Hello World” kernel boots, loads, initializes interrupts and paging, and switches successfully into 64-bit Long Mode.

Now, the real fun can start.

“Throughout my life I have known people who were born with silver spoons in their mouths. You know the ones: grew up in a strong community, went to good public or private schools, were able to attend a top undergraduate school like Harvard or Caltech, and then were admitted to the best graduate schools. Their success was assured, and it seemed to come easy for them. These are the people— in many, but certainly not in all cases—who end up telling the rest of us how to go about our business in computing. They figure out the theories of computation and the semantics of our languages; they define the software methodologies we must use. It’s good to have their perspective, but it’s only a perspective, not one necessarily gained by working in the trenches or watching the struggles of people grappling with strange concepts. Worse, watching their careers can discourage the rest of us, because things don’t come easy for us, and we lose as often or more often than we win. And discouragement is the beginning of failure. Sometimes people who have not had to struggle are smug and infuriating. This is my attempt to fight back. Theirs is a proud story of privilege and success. Mine is a story of disappointment and failure; I ought to be ashamed of it, and I should try to hide it. But I learned from it, and maybe you can, too.”

- Richard P. Gabriel, “A Personal Narrative: Journey to Stanford” (Patterns of Software)

I highly recommend the book, despite vehemently disagreeing with almost every major point made by the author (whom I simply cannot forgive for giving bad-engineering-as-a-virtue a firm philosophical foundation.) RPG remains a top Lisp intellect, and anything he says is worth some serious contemplation.

As I pore over the infamous Lambda Papers, I cannot help but wonder if some of the otherwise bulletproof and immediately relevant (even in our Software Dark Age) ideas within are ignored simply because they carry the faint but even now unmistakable smell of MIT/Symbolics arrogance. I am reminded of how the marginalization and nearly outright obliteration of the once-mighty American railroads was eased by remembered public hatred for Gilded Age abuses — to the enthusiastic applause of auto firms.

This light-hearted song/video mostly summarizes my opinions on existing systems.

The lyrics, for those (like myself) with only sporadic access to the Flash player.

From Richard Feynman’s The Character of Physical Law:

“It always bothers me that, according to the laws as we understand them today, it takes a computing machine an infinite number of logical operations to figure out what goes on in no matter how tiny a region of space, and no matter how tiny a region of time. How can all that be going on in that tiny space? Why should it take an infinite amount of logic to figure out what one tiny piece of space/time is going to do? So I have often made the hypothesis that ultimately physics will not require a mathematical statement, that in the end the machinery will be revealed, and the laws will turn out to be simple, like the chequer board with all of its apparent complexities. But this speculation is of the same nature as those other people make — ‘I like it’, ‘I don’t like it’, — and it is not good to be too prejudiced about these things.”

This paragraph is a perfect summary of the notion which continues to bother me as I study chemistry - the reason why all practical molecular modeling systems are hodgepodges of approximations and empirically-”cheated” heuristics rather than from-scratch calculations based on wave mechanics. The latter rapidly explode in computational complexity for all but the simplest substances. But why must this be so?

Being tormented by this question led me to the following thought:

Either:

I) An ordinary, work-a-day microscopic bit of matter really does require a planet-sized supercomputer to simulate accurately at the particle level. Or:

II) It doesn’t. Or:

III) ???

The consequences would be, respectively:

I) Chemical reactions of some yet-to-be-discovered variety are an untapped gold-mine of truly epic computing power. If some physical system, let’s say a protein, truly has that level of intrinsic complexity - we should be able to harness it to perform computations currently undreamed-of.

II) It doesn’t, and that means we can solve protein folding, “the Universe, and everything” - and emulate respectable fragments of physical reality a la Conway’s “game of life.”

III) I have no idea what III would be. Presumably, some flaw in my reasoning - which held that either I or II is a logical necessity. Perhaps as I continue, I will find out what III is.

It appears that orthogonal persistence, or the elimination of the need for users and programmers to explicitly juggle data between RAM and disk for it to survive plug-pulling, is easy.

We are all running operating systems written with the limitations of 1960s hardware in mind. Not even talking about the future - even the present remains entombed in a box. When can we let it out?

The bootloader runs.

There is truly no excuse for this to have taken so long.

—-

No, I couldn’t have used GRUB - considering that a C compiler is (permanently) out of the question.

If you don’t understand why, (re)read posts 0…N.

Anyone who has read CS papers from ~1960-1980 and compared the original-idea-density to those of today might think forbidden thoughts.

While meandering through stories of unorthodox computational architectures, I was overcome with a sharp feeling of “where are they now?” Who stole the original thinkers of that era, and planted type-theoretical bureaucrats in their place?

Fortunately, the “golden age” works are still in existence (albeit languishing in obscurity on dusty shelves.) They await the patient software archaeologists.

How does one recognize a Dark Age? When it appears that all you must do to turn a field upside-down is to dig out a few decades-old papers and implement the contents, there might as well be a flashing neon “You Are Here” sign, planted squarely in that ominously shaded section of the time line.

In the unlikely event that someone is still reading this, I would like to point out: the project lives.

I am still trying to figure out just how much resemblance to a proper Lisp Machine can be savagely beaten into an AMD Opteron. The focus remains on low-level details of the variety which, when changed, dynamite all subsequent work if one isn’t careful. Some examples:

• To what use can we put the address translator?
• Will using page directory offsets as LispM-style tag bits unleash TLB cache havoc? Just how does the latter work under the hood?
• What perverse use could be made of hardware privilege checking in a system which no longer relies on it for security?
• Are SSE opcodes, with their pipe-clogging effects, worth it?
• Lastly, what of the recent Opteron microcode update hack? Unlikely though it may be, any developments on that front could yield a shortcut leading straight to my destination.

If PG with his infinite free time took five years to spit out Arc, no one should fault me for taking a good long while in my effort to create a computing universe from scratch.

Arc has made quite an impression on me. Implementing it on the bare metal feels like a worthy and tempting goal.

On the other hand, I am saddened by the invincibility of the “programs as plain ASCII streams” dogma even among supposed iconoclasts.