Slashdot Mirror
Microsoft Trying To Appeal to the Unix Crowd?
DigDuality writes "With the news that Windows 2008 (recently discussed on Slashdot) will have GUI-less installs and be fully scriptable, that they've opened up their communication protocols for non-commercial usage and are providing a patent covenant (Redhat Responds), and now finally an interesting rumor floating around that Microsoft will be taking on GNU directly. Has Microsoft totally switched gears in how it is approaching the Unix and FOSS sector for direct competition? According to an anonymous email leaked from a Microsoft employee, it seems Microsoft will be developing a framework that will be completely GNU compatible. Microsoft CEO, Steve Ballmer, said on Friday (23 February) that they are aiming to restore a Unix-like environment to its former proprietary glory, at the same time proving that Microsoft is committed to interoperability. Ballmer emphasized that Microsoft's new strategy is to provide users with a complete package, and this includes users who like Unix environments. According to the supposedly leaked email, UNG, which stands for UNG's not GNU, is set to be released late 2009."
That POSIX layer isn't. It's POSIX only in name, ...
Actually, the proper term is WEIRDNIX.
For those not familiar with the term, WEIRDNIX was the POSIX crew's term for a hypothetical implementation that was technically compliant with all the POSIX standard, but implemented everything in the worst possible way. The idea was to find bugs in the POSIX standard that would allow implementers to claim compliance while violating the intent of the standard.
Mostly, people just sent in specs for a component that followed the standard but would in some way sabotage software that expected the obvious behavior. When NT came out, there were a number of discussions of its POSIX implementation, and a lot of people explained it by saying that Microsoft had done a full implementation of WEIRDNIX. Hardly anyone's POSIX software would run sanely on NT, and that was a simple, elegant explanation of why.
Is there any reason to expect things to be different this time around?
Those who do study history are doomed to stand helplessly by while everyone else repeats it.
[Whew, long post. If your reaction is 'TL;DR' I don't feel bad.]
/. and other places. And yes, this is a big problem. But there is another kind of diversity, which is that Windows is the only major OS that isn't Unixy. Solaris is Unix. BSD is Unix. Linux is Unixy. It's only when you start talking about either research OSes (Mach, L4, Singularity) and old Oses (OS/2, BeOS
The NT kernel... is an interesting beast. There are a lot of things I really like about the architecture it presents. In many ways it has a lot of things that are more modern and better-designed than Unix-descendents (including Linux). At the same time MS seems to have made it more complicated than it "needs" to be, in part to satisfy backwards compatibility and in part because they just seemed to make some decisions I don't agree with.
Some of the good points:
1. Security. Yes, security. This is often brought up as a Windows problem, but that is largely because of policy decisions such as running as admin. (There are also a number of bugs caused by just plain bad coding that lead to buffer overflows. The biggest problem here in some sense is some of the abilities such as sending messages to other processes, which are probably too ingrained to pull out without some very clever modifications.) The security manager in NT provides a lot of very fine-grained control. Related, you don't need explicit file system support and a separate mechanism to do more than RWX on files. (ACLs are absolutely vital in some environments, and things like an "append only" or "create files but no delete" are useful for some applications.) In Unix, sometimes you use chmod, sometimes you use fsacl or whatever it is; the framework isn't unified.
2. Flexibility, in some sense. MS (in theory) can change the system calls that the NT kernel accepts on a whim. This is because all programs are dynamically linked to the Windows subsystem DLLs. These DLLs translate Windows API calls into whatever actual system calls they need. (One API call may generate zero, one, or more syscalls.) It's only the rare, "misbehaving" program that uses the syscall interface directly, and MS doesn't mind breaking them too much. (There are some mostly-legitimate reasons why you need to do this.) By contrast, statically linking code is a bigger tradition in Unix. (Then again, so is having source, so you can recompile if you change your syscall interface.) The idea of having various subsystems that provide different API views is pretty neat, though it's not a fundamental idea. (It's hard to say how it differs from just dynamically linking against just some shared lib.)
3. Not really a good advantage, but interesting and one of the rare examples of where Windows is actually simpler is in the read/write interface. In Unix, my impression is that if you are writing a driver, you "have" to implement to entry points for each: synchronous and asynchronous read, and synchronous and asynchronous write. In Windows, you only implement the asynchronous interface. If a synchronous request is issued, it is handled at a higher level and translated to an async call. (Upside: simpler driver code. Downside: inability to implement just the synchronous version.)
4. It's actually possible to use extended attributes on Windows, though admittedly only because of a huge hack introduced for a related but not-quite-the-same reason. (In Unix, opening a file with an extended attribute in Vi or Emacs, modifying it, and saving it is enough to kill the extended attributes. This makes them next to useless, when I at least can imagine a TON of very useful and neat things you could do with them if you could use them reliably.)
5. The registry gets a lot of hate, but I think a modified version could be better. There are a lot of very nice things it provides over config files. (Transactional access, fine-grained access controls (often nice for a corporate environment, at least in some sense),
6. Diversity. Yes, diversity. People often talk about the "Windows monoculture" on