while (true) //Set CPU in Infinite loop DON'T REMOVE THIS ELSE I'll KILL YOU (^ . ^)
The dedicated part though seems a little more ridiculous to me. Most people who may contributed may not necessary be "dedicated" or even like the project but just may want to help with someone. If I saw a project was looking for dedicated contributors I'd be less likely to contribute anything as I don't want to be married to someone else's project.
Furthermore we also focussed on Mono compatibility (that was way before CoreCLR came out).
Source: Ex co-creator of MOSA
Basically both projects achieved their goals, but Midori eventually was killed by management, even though they got an usable GUI desktop running with some core applications.
Some of their decisions influeced async/await design in C#, the AOT compilers to native code in WP 8.x and WP 10, some of the new features for C# 7 and others planned for future versions.
As for scope M#/System C# style, I guess the door is still open for future C# versions.
Meanwhile You can try building it and play around with source.
edit: ok, found the project license (bsd) but you really should update those headers...
I explained it here:
Only thanks to this kind of work one can prove it is possible.
There are quite a few OS projects written in system programming languages with GC, all the way back to Mesa/Cedar at Xerox PARC.
If you want to have an idea, check the Project Oberon book.
This is the 2013 re-edition, it was originally published in 1992.
No one would though of writing an OS in C++ in the 90's, it was too slow and everyone knew that microkernels could only be possibly written in C.
The "everyone" who knew these things about C++ was a small set of vocal people largely from the Unix and C worlds. Other people who were at the time developing Windows NT device drivers in C++, to pick one example, knew that a lot of the received, and loudly recirculated, wisdom about systems programming and C++ was just bunkum.
What I was trying to convey with that comment was that C++ was looked down for systems programming, it required Symbian, BeOS, OS X IO Kit to change that mentality.
Even Windows that you mention, which always was a more welcoming place for C++ tooling, Microsoft only started to officially support it with Visual C++ 2012 when the /kernel flag was introduced.
So even that microkernel could have been eventually written in System C#, if there was enough management support to keep developing Midori and improving the language to the point C++ wouldn't be needed.
Instead the project was canceled and since in IT, seeing is believing, there will be idea for many, that there wasn't any other way to accomplish it.
I love the way Alan Kay and others like him think, it is not what the technology give us today, but what it can give us tomorrow in a few years time.
Many hobby kernels (as mentioned in these comments) have used C#, as well as bleeding-edge research kernels e.g. Microsoft's Singularity project: https://en.wikipedia.org/wiki/Singularity_(operating_system)
It's legacy will be in their IronClad Apps. Look into those if you want to see how far they've gone. Also, Microsoft Research & HLL vs Nix and C in security are a gap that's ever widening. ;)
For instance, memory safety is process-level in a traditional OS, but object-level in a programming language. So paging logic doesn't make as much sense here, since it would require a lot of expensive runtime support to make every object lazily loaded, not to mention the expense of the bookkeeping overhead to track which objects should be paged out.
This encourages a more event-oriented architecture where programs provide the kernel with continuation when requesting services. For instance, something like C#'s async/await operating at the kernel process level would be one possible approach.
Note: SPIN OS was written in safe Modula-3. Interesting thing about it was leveraging the language safety & a type-safe linker to allow code to be loaded into kernel for acceleration.
Note: LISP machines were among most powerful machines ever created for developers. The language itself had code as data philosophy to change it at will. Runtimes had REPL, incremental compilation per function, AOT compilation, and live updates of code. Do a whole OS that way you get feature 7 along with debugging or linking ones on 8-12 page that no OS has today. I mean, single coolest thing your OS could do is allow debugging or updates of it in high-level code that somehow goes through compiler and right back into memory. The same HLL that users write the applications in.
Note: The main paper on this page will tell you what this OS is about. The architecture tries to enforce POLA at a decent granularity with building blocks that are pretty easy to understand. Almost everything is safe. One thing worth copying is using different, garbage collectors for different apps or parts of OS.
Note: MOSIX was an OS I ran into when I studied supercomputers in the late 90's. The cool thing about it was how it turned a network of computers into a cluster that it automatically distributed jobs over. Treated them like one machine in a way that typically required low-level, message passing. K42 was IBM's attempt at building blocks for something similar using microkernels and hot-swappable components.
Note: Amoeba was a distributed, operating system. Each machine ran some code. The OS and apps were spread among them.
Note: EROS was a capability-secure, microkernel OS with trusted networking and GUI stacks. Abandoned when Microsoft hired Shapiro. Capability model has strong properties for enforcing POLA but one must be clever to minimize overheads.
E language and capability model
Note: Embedding the capability model as constructs in the language, esp RPC's, can make for interesting abilities.
Note: Nucleus is literally stolen from a 70's-era mainframe that did same stuff along with Per Hansen. The idea is you wrap all the low-level stuff behind an interface that forces it used safely & consistently in above layers. Then, above stuff is easy to do in high-level language. The how of this has many possibilities. Safety enforced statically with type systems or Design-by-Contract (e.g Spec#); or dynamically with argument checks; or both.
Are there any technical or practical reasons why systems like Symbolics Genera are inferior to todays mainstream operating systems? Or do you think it's only social / economic processes that they weren't adopted?
Anyway, economics and market demand as usual. That's what killed it.
To free any object instance I have to call Heap.Free
Not trying to be difficult, I'm just wanting to learn more about your project.
(P.S. turns out we are from same college _and_ school)