General Discussions

**Learning Newbie** · 03-13-2008, 04:40 PM

MS has a new OSOS! An open source operating system, written from the ground up in C# with freely downloadable source code. Oh, and the devil says it's snowing where he lives.

They say all operating systems that have more than 15 users are based on Multics, a mainframe operating system released in 1965. Each file had an ACL like NTFS. It had dynamic linkage (like DLL files). And daemons. And multiple CPUs. And ring oriented security like Unix. Even in the 1960s it was a 36 bit OS. Windows, OSX, Linux, and Unix all inherit from Multics.

At a high level this is what Microsoft says about it

Quote:

Technically Speaking, Singularity Is Different Singularity differs fundamentally from other operating systems in that it is written almost entirely in an extension of C#, a modern, high-level programming language. This enables a more dependable overall computing environment because C# gives Singularity security advantages over operating systems written in lower-level languages such as C or C++. For example, by using C#, the researchers prevented a class of errors known as buffer overruns, thereby eliminating an area of vulnerability typically exploited by worms and viruses.

Singularity also incorporates three key architectural features to improve system dependability. First, Singularity pioneers the use of software-isolated processes (SIPs) to help protect programs and system services. SIPs enable programs to be broken down into components that are isolated from other software components running on the same device. This enables pieces of a system to fail without risking a total system failure. Consider this analogy: In a car, the brakes don’t fail if the radio stops working.

“In the past, creating many processes in an operating system was impractical from a cost perspective, largely because they required special support from the hardware,” Hunt says. “Rather than use hardware to build boundaries between processes, we figured out a way to build processes using a software technology called static analysis.”

Static analysis, a large and important research area at Microsoft Research, inspects a program’s source code in advance to make sure a process obeys certain rules that guarantee it’s isolated from the rest of the system. Traditionally, programs were checked at run time, using hardware mechanisms that date to the less-disciplined code of the mid-’60s.
Singularity’s second noteworthy architectural feature relates to the fact that a program’s many SIPs need to communicate and share information because they work toward shared objectives. To avoid miscommunications that can lead to errors and breakdowns, the Singularity researchers developed what they call “contract-based channels” for communications.
“We figured out how to describe the form in which communications should take place between two processes, and using static analysis, we can check the codes of the processes at compile time,” Hunt explains. “So before the code ever runs, we can confirm that the processes communicate correctly.”

Singularity’s third unique architectural feature, called “manifest-based programs,” represents another shift in orientation. Traditionally, operating systems have had no “knowledge” of a program’s composition, its purpose, or the resources it uses. Presented with a set of bits, the operating system would simply run them. Singularity, with its emphasis on overall system dependability, takes a different approach to ensure that a new program won’t “break” the programs already on board.

“We basically say, if you want to install a program to run on a Singularity system, you have to provide some information about it so we can preserve certain properties that make the system more reliable,” Larus explains. “You have to provide a manifest of the program pieces and how they fit together, and we’re going to check it. More important, we reserve the right to say ‘no.’ If a certain program doesn’t follow the rules set down for the system, you can’t install or run it.”

This ability to start with a clean slate and to retool how software is written—from the ground up—is a testament to the spirit of innovation that permeates Microsoft Research, Hunt and Larus say.

“Singularity was only possible because the environment at Microsoft Research allowed us to collect a diverse group of researchers eager to participate in a project to fundamentally rethink a basic part of everyday computing,” Larus says. “Applying everyone’s research perspectives helped us understand and demonstrate a new way to construct software systems.”

**ForrestCroce** · 03-13-2008, 09:21 PM

How do you write an operating system in C#? You need the framework to run your code ... let alone a bootstrapper.

If it's safe because it's .net, which is what they seem to be saying, you need the common language runtime to provide that safety for you. Things like checking the bounds on an array before trying to access a slot, since the buffer overrun part is bolded and underlined. On that note, though, what's wrong with just fixing the broken methods that use buffers without checking to see whether a piece of memory they want to access is part of the buffer?

Highly optimized C# code is 20 to 30 % slower than C++ because of the runtime checks, and to some degree JIT. You can ngen your code and possibly get closer to 20 % than 30, but managed code will never be as fast as petal to the metal native code. Most of the time, that's ok. A text editor can show less than perfect performance. An O/S kernal or database engine can't.

**cbwm** · 03-13-2008, 10:03 PM

http://en.wikipedia.org/wiki/Microsoft_Singularity

The lowest-level x86 interrupt dispatch code is written in assembly language C. Once this code has done its job, it calls the kernel, whose runtime and garbage collector are written in C# and run in unsafe mode. The hardware abstraction layer is written in C++ and runs in safe mode. There is also some C code to handle debugging. The computer's BIOS is only called during the 16-bit real mode bootstrap stage; once in 32-bit mode, Singularity never calls the BIOS again, but rather calls device drivers written in Sing#, an extended version of Spec#, itself an extension of C#. During installation, CIL opcodes are compiled into x86 opcodes using the Bartok compiler.

Looks like C# is just for the parts they want you to plug into. The whole thing is a very curious direction for Microsoft to take and begs the question why. I have to admit, if they did re-write the OS as a quality product from the ground up, they have the market presence and cash to make it fly and perhaps stave off the inevitable a bit longer.