You can buy the annotated source code for Oscar Toledo G’s Nanochess here:

http://www.amazon.com/Toledo-Nanochess-commented-source-code...

It was certainly a humbling experience for me.

Underground but with an Internet website, github and HN account? probably you are hyping it a bit too much.

http://www.biyubi.com/eng_principal.html

https://news.ycombinator.com/from?site=github.com/nanochess

https://news.ycombinator.com/user?id=nanochess

Assembly was one of the first languages that I wrote in when I learned to program in the 80's, simply because other languages were too slow to develop games and other stuff. Since then I've switched to Pascal, Java, Scala, Python etc. But sometimes I still miss the joy of micro-optimizing some assembly code until perfection.

This Toledo family is amazing. I wonder if this will be the future of SD craftmanship, now that Moore's law seems to come to an end and we are forced to look at optimizing the performance of our software stack.

It's so incredible I can't digest it.

Well now you made me curious to learn more about this mythical OS and browser... any leads?

I've read about them before, and Oscar's seemingly complete mastery of these type of things.

It makes me wonder what he does professionally, and how much it pays. Is it a valuable(to companies) skill even?

Another HN thread on Toledo: https://news.ycombinator.com/item?id=28337064

This reads very aggrandizing and hyperbolic.

Let's find a way to fit an LLM into 512 bytes!

What? Why?

A typical microkernel will have user programs that drive the hardware that expose a very similar interface to what a macrokernel would provide, from the application level there isn't a whole lot of visible difference but at the system level there is, essentially the macrokernel is broken up into a number of separate processes each of which is fashioned as a 'normal' user program. This significantly reduces the scope of the kernel itself which has a whole pile of interesting implications which usually manifest as massive reliability improvements over macro kernels, a penalty in raw io throughput and the ability to elegantly (on the fly) load and unload all kinds of OS components without the need to reboot the system.

But there usually is a clear distinction between such 'kernel processes' and user applications, they also tend to be run at a slightly higher priority to ensure that the system keeps moving.

Warning: big piece of opinion that may trigger some of you.

In practice (feel free to verify this yourself by downloading and building the latest L4 derivative), microkernels that actually work on modern hardware need a huge amount of baseline code to get IPC and memory server working in a distributed yet somewhat performant fashion.

There is a flag for compiling Linux without any hardware and filesystem drivers. That gives you the kernel core in a surprising small binary which is not that far from sel4 or okl4.

In summary, monolithic is the new microkernel :)