This is a medium-high-level discussion about general computer program organisation. For lower-level CPU design tricks, dos and don'ts, please check it out: #PDP - Processor Design Principles :-)
The way we are used to program computers is a long evolution, and selective pressure has favoured bad habits, among others.
Safety and security are not guaranteed, ASLR and NoExecute flags don't prevent the constant stream of dumb and preventable vulnerabilities (out of range access, buffer overflows, stack smashing, various leaks, Return-Oriented-Programming and so many exploits). I'm not speaking about cache and buffer coherency/timing issues here, which are detailed architectural issues.
Of course, no program is flawless and "there will always be bugs" but so many of them depend on the platform allowing them. This project will not revolutionise software engineering but tries to define techniques, structures and features that prevent many of the above-mentioned exploitable side-effects of the current generation of monolithic kernels (which are themselves architectured around existing CPU's programming models).
This project also tries to enable a new generation of capability-based microkernels, which influence this work. I tried to generalise their structure and keep the most fundamental features for inclusion as processor features.
1. POSIX is a curse
2. Read as Zero
3. The cellular allegory
4. Introduction to the new model
5. The watered-down OO Paradigm
6. Code space structure and management
7. Executable files' structure