Thanks to the improved Single Static Assignment (SSA) stage and several new post SSA optimizations, the resulting code quality of MOSA compiler has improved substantially. On the x86 platform alone, this has resulted in staggering 18% reduction in the executable binary code!
The MOSA Test Suite has expanded to over 100,000 test cases!
Simon Wollwage (rootnode) is on a roll with new MOSA compiler features recently. He just added support for static and non-static delegates and with optional parameters. This was an unplanned roadmap addition!
Thanks to the hardwork of Simon Wollwage (rootnode) he completed support for .NET Generic Types in the MOSA Compiler. It's major deliverable for the 1.0 release.
As you may have noticed some project issues are missing from our website. That's because our web server had a hard drive failure and our backups were three months old! So to improve the website's reliability and uptime, in addition to increasing responsiveness and bandwidth, we have transfered the website to Dreamhost Internet Service Provider (ISP). They provide automatic backups, generous disk space usage and unlimited bandwidth for a reasonable price.
We hope you like the improvements!
If you wish to support the MOSA website, please visit our Donations page.
Welcome to the first issue of the MOSA newsletter. The objective of this and future editions is to highlight areas of progress and interesting points of development. Though there will not be a set schedule for newsletter releases, the project hopes to at least provide a semi-regular update for people interested in MOSA. We hope you find them to be informative and helpful.
An operating system is in many ways like any regular program in that it is composed of lines and lines of code. Generally any complexity in it is due to minimal handholding and support in the form of libraries and higher level abstractions, since the OS being written is supposed to provide them. Other issues often deal with the quirks of faulty or non-comformant hardware which the OS has to compensate for. Even then, one tends to have at least a minimal amount of tools to work with like a compiler or assembler. Things get much trickier however when using a language that was not intended for system programming.
The Manged Operating System Alliance has been working on the infrastructure necessary to allow operating system development using C# and the .NET Framework's Common Language Runtime (CLR). Part of this effort is an ahead-of-time (AOT) compiler for the Microsoft/Common Intermediate Language (MSIL). As MSIL is the common bytecode for the CLR, a compiler that can convert it directly to machine code instead of just-in-time interpreting it would be very valuable. Both Microsoft and Mono's compilers can do AOT compilation, but both sit on top of unmanaged environments. The Mono runtime for example relies on the C runtime library. However, since the point of MOSA is to create a completely managed environment for software to run in, its compiler and runtime cannot have any dependencies on unmanaged components. On the other hand, Mono's C# compiler is already completely written in C# and should not have any problems being dropped on top of the Mosa runtime when it is completed.
The act of producing a functioning executable out of source code involves two major steps, compiling and linking. Compiling takes the source code and turns it into machine instructions while linking takes the generated objects and packages it into a properly formatted executable. The compilation stage is also composed of several stages that consume the code written in higher level languages and break it down into an intermediate form to perform optimizations on. Though MSIL is already an intermediate language, it was not low level enough for the purposes of certain optimizations and direct conversion to machine code. While there exists many other lower level intermediate languages, none of them have managed environments that work with them. As a result, the MOSA developers have created their own custom intermediate language to fill this gap. Fortunately, progress has been steady and the MOSA compiler is capable of being used for procedural programming, allowing for use of static functions and most math operations. Thousands of unit tests for the various MSIL instructions have been committed to ensure the emitted machine code behaves correctly with even more on the way. Currently the objective is for correctness over speed so little work has been done on optimizing output. However, developers have been looking at various compiler optimization techniques so that when time comes to implement them they will have a good feel of how to proceed.
Support for object oriented programming requires implementation of the "this" pointer that references an object, essential for keeping track of which instance of an object is being operated on. Another requirement is dynamic memory allocation and all the metadata that describes an object's internals. The MOSA team has completed an initial implementation of the "this" pointer but memory allocation is considerably more complex as it requires not only support in the managed runtime but also reaches down into operating system memory management. As such testing of this feature will also require a more complete environment, with at least a base operating system and an application runtime.
The MOSA compiler and kernel can now instantiate new objects and arrays!
Michael Fröhlich implemented the new operator for static objects at compile time. You can read more about it on his blog entry:
As you can see, we've ditched Retrospectiva in favor of Redmine. It works way better in terms of E-Mail, Repository browsing and especially updating the local repository.
Furthermore it offers a forum and many many more. The development is faster and the community larger.
So, many many reasons. We've imported the complete old wiki and set up most of the old user accounts.
Also available in: Atom