OK wrote:
> http://channel9.msdn.com/showpost.aspx?postid=227259
Gee, this sounds like something right out of the Linux playbook.
Rethink how software is constructed and start from "bare metal"
(Linus started with the premise that he wanted to write for the 80386
chip).
(He studied minix, but started from scratch).
Choose a reliable trusted infrastructure
Microsoft used C#
Linus used GCC, glibc, and OSS foundation software.
Choose a model that lets developers find errors easily.
(Linus used macro-kernel with plug-ins rather than microkernel for
this reason).
Isolate processes and process memory from each other
(Linus used memory mapping to make sure that process context
switches were fast,
he also used this to protect each process from other processes).
Communicate over channels.
(Linux and Unix primarily use pipelines and message passing between
processes. Linus optimized these by using memory mapping to protect
and pass messages very efficiently).
Minimize the amount of shared memory between programs.
(Eliminate all of the deadlock and race conditions by
limiting or eliminating all shared memory between processes or
threads -
- again, back to BSD and Bill Joy's system design).
(Linus again used memory to minimize the ability to move memory, he
also minimized threading within the kernel).
Use "contracts" between program components and programs, so that only
the "contract" needs to be considered.
Sounds a bit like Man Pages to me.
They don't have plug-and-play yet
They'll steal it from Linux any day now.
They don't know how to actually build Singularity, may be 5-10 years
down the road, maybe by 2015! WOW - only 10 more years before the BETA
release of Microsoft Linux!
.
The Linux community figured out how to generate a huge community of
engineers, analysts, and programmers who were able to contribute
based on their social, personal, and economic interests.
Research engineering is 90% of the development, and the last 10% takes
99% of the time.
Gee, if we do it this way, it's fast, lots faster, and more reliable
than anything Microsoft has now!
(Pretty much an admission that the design principles of Linux are
better than those
of Microsoft and Windows/Vista).
Small kernel that provides very basic features.
Isolate the disk drive software from kernel.
Isolate the file system from the kernel.
Isolate the network drivers from the kernel.
Isolate the other device drivers from the kernel.
Isolate the protocols from the kernel
Sounds like Linux "Modules" to me.
Isolate components (from each other into separate processes, and let
them communicate with each other using message passing (do I dare use
the word "pipes"?).
Each process has their own run-time process, heap, and garbage
collectors.
(Linux again!!!, object pools, JAVA, J2EE object pools).
Use fully compiled code, not a JIT
(Linux again).
Kernel interface between kernel and process which is very limited.
(Linux, X11, pipelines, ICCCM, message queues).
Processes can ONLY talk to other processes via message passing through
channels managed by the kernel - to other processes.
Limiting the interfaces and what they can communicate with. For
example, a process can only talk HTTP to web interface, it can't do
it's own TCP/IP. Gee, sounds like Linux again.
Configuration requirements
(check PCI code, check for conflicts, is it already installed...?)
Sounds like modprobe - Linux again!!!
Each process/driver is type-safe and memory safe - can only interact
using the available application, Each process is isolated.
Sounds like SINE, streams, modprobe, and CUPs.
Only kernel can map/access directly to hardware addresses.
X11 Server, CUPs, SINE, Xen...
Use reliable code
Microsoft keeps trying to say C#.
Linus just used really well-tested components written in C,
compiled with GCC, using glibc/libc library, all "hardened" over 25
years in production enviornment and under OSS scrutiny (BSD, GNU, X11,
MIT, Athena...).
And just think, we only have to wait AT LEAST 10 MORE YEARS for
MICROSOFT to DELIVER!!!
AND GIVEN THAT MICROSOFT is CONSISTENTLY 300% LATE, it could be here by
2036!!!
I CAN'T WAIT!!! (thank goodness I don't have to).
Microsoft: How do we do that? We don't know yet!!!
Microsoft: No Guarantees!!!
Microsoft: Our current software is really buggy, but we'll fix that
(in 2036?).
Let's group the applications into one "hardware boundry". (Xen Virtual
machines?).
After listening for 40 minutes, this is sounding more an more like
Linux OS, Xen, and Windows applications running in small Windows
virtual machines.
And Microsoft thinks they might be able to deliver in 10 (20?, 30?)
years!!!
The really sad thing is that these guys on the singularity team seem to
have no clue that they have been spoon fed nearly all of the
fundamentals of Linux. One of them (the guy in the green sweater and
white shirt?) probably does know, but is acting like they don't know.
The rest of these guys HAVE NO CLUE THAT THIS IS LINUX!!!
And then they degenerate back into the same mess of Windows, putting
everything in ring zero. Can we shoot them now?
OOPS! They seem to want to create separate copies of everything,
instead of using "copy-on-write". Linux maps the shared pages
separately, prevents writes to code pages, and text pages, and does
"copy-on-write" for buffer pages. Exec can load only what is needed,
back to same core libraries (but read-only).
57 minutes in, they want to go to flat memory model, no MMU, so now
they want to invent OS/9. Boy does that sound like fun!!! Yuck!!
Back to *nix from 1976?
Oh well, they have 10-20-30 years to sort all of that out.
Microsoft is still trying to figure out how to deal with Multiple
Cores.
Linux has had that figured out since Beowulf!
How about Xen?
1 hour and I'm more convinced than ever that Linux is going to blow
Vista away!
|
|
