Slashdot Mirror
Fresh Air For Windows?
jmcbain writes "The NY Times has an opinion piece on how the next Windows could be designed (even through Microsoft has already laid plans for Windows 7). The author suggests 'A monolithic operating system like Windows perpetuates an obsolete design. We don't need to load up our machines with bloated layers we won't use.' He also brings up the example of Apple breaking ties with its legacy OS when OS X was built. Can Windows move forward with a completely new, fast, and secure OS and still keep legacy application support?"
They could throw some time and effort (and $$?) into the support of WINE to allow the use of legacy Windows applications in an 'archaic OS'
There was a time when a much leaner Microsoft highly respected and rewarded employees who could write good code. These were the people who rose to positions of responsibility. Today, Microsoft is run by Sales and Marketing and coders are viewed as an expense. Until this situation reverses itself, don't expect any improvement in the product they create. They are too stupid to realize their product is the code. Ballmer being from sales only reinforces this problem. Perhaps he should be moved to a chair throwing division that does the monkey boy dance, and someone who can both create great code themselves and manage coders should be brought in as CEO.
Because most Linux users want apps made for Linux, not Windows and then emulating the Windows API on top of Windows. WINE is great and has uses but basing a distro around it really isn't a great idea as WINE changes so quickly. Also, most Linux distros that are popular don't even try to act like Windows (Ubuntu, Mint, Debian, Fedora, etc) and the ones that do act like Windows usually fade into obscurity, (Linux XP, etc).
Taxation is legalized theft, no more, no less.
Comment removed based on user account deletion
An IBCS-like layer in Windows plus WINE-like shim DLLs would be quite sufficient for the majority of legacy code. In fact, if they used IBCS as a starting point, they could also suppor legacy Solaris, legacy Unixware and legacy Linux applications as well, with very minimal effort. As for retaining Intel support, I'd say that at minimum, there has to be Intel binaries, although the adoption of the Cell processor might not be a bad idea. Sun's T2 is too expensive and they'd never be able to scale production up fast enough, although the benefit to Microsoft of an open-source processor is that they could shift some of the core routines and helper functions into the CPU itself. (They have the money to sway Sun into applying the patches at the fab plants.)
It's a small world and it smells funny; I'd buy another if it wasn't for the money; Take back what I paid (SoM)
That makes no sense, given that there old DOS based system when through "Windows 1.0", "Windows 2.0", "Windows 3.0" and "Windows 3.1".
Are you saying that Windows 3.1 was not Windows?
The cake is a pie
Sort of like what Apple did with OS 9/OS X?
If so, the trouble with that might be that the legacy OS (Win XP or Vista) is so large that the legacy OS portion would double the size of the installation. If I recall correctly, the OS 9 support in OS X only added 400 MB to the installation, as OS 9 itself wasn't that large. What was really nice about it was that it could easily be removed if you didn't need the legacy support.
(I may be wrong in my size estimates or misunderstand the OS 9 legacy support, as I moved from Windows XP to OS X when Tiger was released and have little experience with OS 9.)
Government's idea of a balanced budget: take money from the right pocket to balance...oh who am I kidding?
Bashing Vista has become like pouring hot grits on Natalie Portman around here. It's just a meme anymore. It was funny for awhile but now it's just old.
Vista really isn't all that bad. I still have XP machines (and Linux, and OS X, and Solaris, and OS/2 even) but I don't mind my Vista machine at all. I also run a lot of old apps on it just fine.
Yeah, indeed ;)
Or they could, like, ditch all their work done so far, fork wine and make the new OS run on top of linux+wine, possibly off a sqlite-based WinFS ;)
Then just port their platform libraries onto that, redo their visual tools as eclipse plugins -- and presto, you have best of both worlds.
And fast ;)
It's the API layer. Win 3.1 and NT 3.1 = 3. Windows 95 and NT 4.0 = Windows 4.
Are we not in the time where everyone and their brother is using virtual machines? It would seem that MS should relegate legacy support to virtual machines instead. They have the source code so they could "easily" create a VM (or some very transparent layer that makes it look like its running natively) for each version they've ever sold.
Then they can do whatever they want and just keep the VM layers up-to-date.
I surely can't be the first to think of this...
:wq
How is 400 MB even slightly an issue? My Windows Vista "Windows" folder is 6+ GB right now, although that might include some caching and such that isn't on the install disk. Either way, 400 MB is nothing. (And that all said, I'm pretty sure OS 9 only weighed in at something like 120-140 MB. I used Mac OS 6.0.8->10.4, stopped when it became apparent Apple had no interest in improving basic OS components like Finder and instead focused on adding shiny crap I don't need or use.)
Anyway, I think the real problem is OS integration. Any legacy support "layer" from Windows would need basically full access to things outside the layer, from drivers to OS features like drag&drop. This makes the process of writing this layer extremely complex, and could potentially erase any speed improvements Windows 7 could benefit from in the first place.
Classic had two problems:
1) It was slow, very slow. Classic running, even when totally idle, slowed down OS X by something like 40%. Which I think is due to the issues I brought up in the last paragraph.
2) It didn't run hardly any goddamned applications. Sure, Classic emulated the 10 or 15 most popular OS 9 apps, but it was hitting pretty damned low in the compatibility chart. Among the software I owned, it ran maybe 75%, at best. Microsoft can't afford that; 75% compatibility would put them out of business. Vista has like 95% compatibility, and you've heard all the whining around it.
Comment of the year
Everything on your list sans the last one, and much more could fit on a fucking LiveCD, and expand to a couple of gigabytes. Even Windows XP had all that and it fit onto a 3 gig partition easily. Microsoft has no excuse for Vista's size, other than sheer incompetence.
But the entry that totally shows how clueless your post is happens to be this one:
Multiple filesystem support
Oh please. NTFS, FAT, ISO+Joilet, UDF, a couple of network "filesystems" perhaps? The Linux kernel contains many times as many filesystems, and even if you enable all of them, your kernel image will hardly ever be more than 20-30 megabytes when you compile it. You just needed to put something on what is a short list, didn't you?
As for Most extensive driver library in existence, it's not true. Most drivers come either through Windows Update (network) or via the vendor (install CD or website). Out of the box, Windows support the bare minimum it needs to run with terrible performance.
Last but not least, all the stuff falling under monster domain features is functionality. Lots of source code which gets compiled into tiny binaries. Since when does implementing "ACLs on every resource" or "domain controls enforced" on clients require gigabytes of data?
I'm definitely a big fan of Apple stuff and am likely more tolerant of the small bugs that come out from Cupertino, but I think many people here are missing the big picture: Windows is all about compatibility. That's why a business might spend millions of dollars developing apps on Windows, because they can milk that cow for a long time afterwards. Vista is a significant enough break from Windows XP that many businesses don't want to switch because it means a potentially lower bottom line. Windows has incredible software inertia, while the Mac really doesn't. Comparing Mac OS and Windows is, well, comparing apples to oranges.
Basically, if your bottom line depends upon a very slowly moving software architecture, then Vista is probably a bad thing. Making big changes, on the other hand, makes things potentially easier for Microsoft as there is less legacy and code can be refactored given years of experience.
If only I had mod points today... ;-)
Seriously, I'm not a fan of MS by any standards but I have Vista installed on my desktop box and it annoys me less than XP on my laptop does. It's not a bad OS really and good enough for me not to scrub it and install Linux instead. Years ago, I couldn't stand Windows and always hosed the HD so I could put Mandrake or Debian on, but now I find Vista to easily be good enough.
bang goes my karma... again...
Make the engine, upon which the winning succinct byte code runs, a new W3C standard browser programming language (or at least virtual machine) and reduce the Microsoft OS CD to those components required to create a web-delivered application platform using the winning engine. Such an engine would, of course, have some features that dynamically encached expansions, memoizations, tablings and/or materialized views similar to the Hotspot optimization technology that originated with the Self programming language (and was later adopted by Sun's Java Virtual Machine). Hence it would make sense to have the OS CD contain a partially pre-expanded hence time-optimized code base.
Then, for delivery of software services to pre-existing platforms, create a legacy port of the services code to pre-existing W3C standards like XForms implemented in a downloadable ECMAScript Client/SOA library in a manner similar to the way TIBET(tm) does. The idea is to go "Live", ie: web-delivered, with a fundamentally new W3C base (whatever engine won the prize) but support legacy W3C environments for migration.
Again, this prize-oriented strategy would, of course, require a rigorous specification of the software services so the testing could be largely automated.
This approach addresses Microsoft's 2 biggest problems deriving from the same fundamental reality: Everyone has needed their OS to interoperate with the bulk of the information industry.
The first problem is ethical and really goes beyond the scope of my professional opinions to my public opinions about the support of property rights. Suffice to say, I have no trouble with someone who goes after a natural monopoly position and succeeds. I have a problem with someone who then refuses to use that position of success to fix the bug in the society that made them inordinately rich and their technology inordinately influential.
The second problem is technical, which is what my argument here is really all about.
Basically Microsoft's code bloat problem derives from its monopoly position. This may seem like a truism since all of the software "profession" suffers from code bloat, but only Microsoft can take this to monopolistic proportions -- proportions that make Ma Bell's monopolistic complexities of yore look Spartan.
So Microsoft has this problem and it has many programmers (contributing to the code-bloat problem). It also has mountains of cash.
So how can Microsoft bust its own monopoly position turning its many programmers and mountains of cash into succinct code?
Monetary Incentives for the Programmers, ala the Hutter Prize:
S = size of uncompressed code-base
P = size of program outputting the uncompressed code-base
R = S/P (the compression ratio).
Award monies in a manner similar to the M-Prize:
Previous record ratio: R0
New record ratio: R1=R0+X
Fund contains: $Z at the time of the new record
Winner receives: $Z * (X/(R0+X))
It may turn out that due the incomputability of Kolmogorov complexity, the growth of reward may need ultimatelyto go exponential but the principle remains true.
What happens very rapidly is the programmers first apply their skills to maximally refactoring. What falls out is a series of legacy API layers written atop a tight core.
They'd have to spend more money on code testing to verify the compressed code-bases of the competing teams actually worked to spec but the results should be quite gratifying.
Seastead this.
For kicks I recently setup Oracle 7 on a spare box running XP, considering it was originally ported to NT 3.51 it's working surprisingly well for a 13 year old piece of software. As long as you stick to core stuff, the NT lineage is amazingly backwards compatible.
Still, compare this to UNIX software - which may not be binary compatible (being rooted in minicomputer culture), but on a number of occasions I've compiled 20-25 year old applications with only a few very minor changes to account for GCC's bitching.
So whats the new approach for future? Give us the source code and we'll figure it out :)
I agree that it's not a bad OS... just horribly unfinished. "Release early" works for open source projects, but is not something we expect from a commercial entity like Microsoft.
My Dell XPS has a host of Vista-related problems (i.e., fails on Vista but works on XP). Some have nothing at all to do with the OS. For example, VMWare Server doesn't work quite right on Vista (can't change certain settings), but it works flawlessly on XP. Some are partially the OS and partially a third-party issue. E.g., the wireless keeps on disconnecting. The drivers from Broadcom are the culprit. But by disabling IPV6 the disconnects occur less frequently. Then there are pure Vista issues. For example, Vista does not hibernate properly. The pre-linker is not tuned properly and can thrash the disk for hours. And why can plugging in a USB network device cause Vista to bluescreen?
Decisions that aren't bad in themselves are not well thought out. For example, prompting to allow every app that runs may help security. After a while though it can get annoying and soon after that it becomes useless because we've been conditioned to just allow everything.
Spin off a new company whose sole mission is to support legacy Windows applications. You really have to make this fork at the "corporate mission" level. Since their mission would be archival and historic support, the Legacy Windows Corp could even get excited about supporting customer's custom code that works perfectly well but is threatened by forced upgrades.
Don't discount the source, either -- it was one author with an existing relationship with a mole within the company, taken over several years that was sponsored by a reputable newspaper. The book presented a lot of historical detail, naming names and specific events, with very little speculation.
One of the interesting insights was the exact process of how the code for OS/2 diverged during the Microsoft/IBM code divorce, viewed from the effect on IBM. A good Microsoft insight from a non-Microsoft source and PoV. Strongly recommend the book, not the least because it's the only written history of that transition I've seen.
Pity there isn't more written history of technology; when this "golden age" is written about some time in the future, the fascination will be the thought processes surrounding the events more than the details of the technology. It's the same reason why The Mythical Man-Month is still relevant today.
Do not mock my vision of impractical footwear
Virtual pc will be used to run really old windows apps for compatibility.
The windows 7 kernel is only 26 megs as was demonstrated and vista provides alot of layers in software to port to the new kernel to make it easy.
If anything windows 7 is turning more exokernel in alot of ways which will prevent what happened with vista where it was so bad ms had to start over many times with a new design with layers.
http://saveie6.com/
Thats a horrible idea. SQLLite is *really*, *really* slow compared to an in memory database.
ZFS is the way to go. ZFS fixes real world problems. WinFS just makes searching/tagging more convienient? That is useless to most users.
I fear the Y2038 bug
I'm not sure I understand your questions.
The DOS emulator on Unix was faster than native DOS on the same machine.
I can't recall the Win 3.1 emulator on unix having any performance issues, to the contrary.
Don't some of the Windows games that currently run under WINE have more FPS than natively under Windows ?
So, yes, running Microsoft originated OS on Unix can result in a faster and more stable experience.
Extremely well said. At most let me add my own lament to Microsoft. Why can't they spend some time making their OS less of a memory hog and a little bit faster. I could honestly see businesses migrating to an OS that had the same feature set as XP but ran faster and with less memory.
I wish it would happen some day but I doubt it. Instead we'll get more "cool" 3D windowing effects when we open and close our applications, it will run like a cripple, and use up 2 GIG of DDR3 in no time.
Surprisingly, you're wrong.
Sandboxing an unstable app or OS is a good way of improving the overall stability of the system. Check this out, for example;
Vx32 is a user-mode library that can be linked into arbitrary applications that wish to create secure, isolated execution environments in which to run untrusted extensions or plug-ins implemented as native x86 code. Vx32 is similar in purpose to the Java or .NET virtual machines, but it runs native x86 code, so plug-ins can be written in ANY language, not just Java or C#.
http://pdos.csail.mit.edu/~baford/vm/
"I've got more toys than Teruhisa Kitahara."
Funn, my dad is partially computer illiterate and he just acquired a Dell machine.
It came with vista home, and his first impression is that the new windows does not let him do a lot of things (either because it blocks them or because they are hidden in places different of where they were on XP).
I was very surprised that he asked me to help him install Linux instead. That is quite funny because the last time he tried Linux was IIRC with Mandrake 7. And it was a complete disgrace. What I did is to tell him where to download Ubuntu.
If "normal" people (i.e., not geeks) are complaining about vista, for some perceptible issues, I think it is not as good as it should be...
Ubuntu is an African word meaning 'I can't configure Debian'
Seems odd for such a non-technical article to latch onto a term like "micro-kernel" like it was all hot and new. OS X is built on a BSD which has it's roots in 60's and 70's OS design, just like the VMS roots of WinNT.
OS X didn't change the world by bringing some great new underlying architecture to the table. In fact, their kernel and filesystem are arguably getting long in the tooth. The value that OS X brought to the table was the fantastic Carbon and Cocoa development platforms. And they have continued to execute and iterate on these platforms, providing the "Core" series of APIs (CoreGraphics, CoreAnimation, CoreAudio, etc.) to make certain HW services more accessible.
There's very little cool stuff to be gained in the windows world by developing a new kernel from scratch. A quantum leap to something like Singularity would not solve MS's problem. The problem is the platform. What's really dead and bloated is the Win32 subsystem. The kernel doesn't need major tweaking. In fact, the NT kernel was designed from the beginning such that it could easily run the old busted Win32 subsystem alongside a new subsystem without needing to resort to expensive virtualization.
Unfortunately, the way Microsoft is built today it have a fatal organizational flaw that prevents creating the next great Windows platform. The platform/dev tools team and the OS team are in completely different business groups within the company. The platform team develops the wonderful .NET platform for small/medium applications and server apps while the OS team keeps crudging along with Win32. Managed languages have their place, but they have yet to gain traction for any top shelf large-scale windows client application vendors (Office, Adobe, etc.) Major client application development still relies on unmanaged APIs, and IMHO the Windows unmanaged APIs are arguably the worst (viable) development platform available today.
What Windows needs is a new subsystem/development platform to break with Win32, providing simplified, extensible *unmanaged* application development, with modern easy-to-use abstractions for hardware services such as graphics, data, audio and networking (which would probably look not entirely unlike an unmanaged counterpart to WPF/WCF/WinFS).
-- Samir Gupta, Ph. D. Head, New Technology Research Group, Nintendo Co. Ltd., Kyoto, Japan.
Technically, "Windows 2000 Professional" was something you could call a merge, as it brought up-to-date DirectX and USB support to the NT line. It did, however, NOT support all existing DOS programs, unlike Win98.
But for whatever reason Microsoft was not ready to sell a "home" version of Windows 2000. So they released Windows Millennium instead. Yes, that was another DOS based system "after the merge".
Millennium was a major disaster and Microsoft soon followed up with XP Home. XP Home was the first NT-based Windows marketed to the home user, so it looks like the successor to Windows Millennium. But technology-wise, it is Windows 2000 with more eyecandy and crippled user accounts (the non-crippled version is called XP Professional and the direct successor to Windows 2000 Professional).
C - the footgun of programming languages
Microsoft people have openly said that they want fewer hardware manufacturers. I wouldn't be surprised if this was a major reason in changing things the way they did.
The perceived problems with Vista are largely from functionality we asked for. We wanted greater security, since the security problems of Windows XP essentially launched the multi-billion dollar spyware industry. Vista attempts major security improvements, and the people howl.
Frankly, it's been so long since a major OS change, people forgot what a nuisance it can be. Where Vista falls short is that it lacks obvious compelling reasons to change.
If the next operating system change is worse for backwards compatibility, it will be hated even more then Vista.
Here we go again....windows is rubbish blah blah....apple is better blah blah....linux is best blah blah... The clue was in the statement pointing to Apple's OS X - while ignoring that in the grand scheme of things, *no one uses it* - especially since they decided to abandon their old OS (no backwards compatibilty? That'll sell). Imagine if MS had brought out XP with a proviso that you had to wait for W95 to run on top of it before you could run any old apps...Gates would have been stoned to death. Ditto linux. This race was over decades ago, when Apple, Digital, Novell and Netscape went for the dollars instead of the users. Now here we are, squabbling over which app is claiming the most of what's left of the pie MS have almost finished. Firefox? No Group Policy controls, plus I can bring up a users' passwords, in clear english, with three clicks - Hmmm very secure. And MS have already stolen the best bits (as they always do). Linux? No Support. From a corporate point of view, that means End Of.
This has basically already been done with Windows Vista 64-bit. There is a lot of backwards compatibility issues with this version that I don't think have been or will be addressed. The plan for backwards compatibility for Microsoft going forwards is going to be virtualization. I do that now for many of my old office programs on Vista 64. The whole microsoft debate seems to me to be really losing a factual basis. Many people fail to realize the true paradigm shift WITHIN vista as opposed to between vista 32 and xp 32 bit.
Yup, Windows 2000 added plug 'n play with USB support (notoriously absent from Windows NT), full DirectX support, better 16-bit compatibility support, a more fully-featured DOS emulator, and the easy network configuration developed for Win9x. You could also enable compatibility mode for older programs, although it was not enabled by default.
The only things XP offered on top of this were better DOS emulation, compatibility mode already enabled, slightly tweaked schedulers and kernel, remote terminal support (XP Pro), and of course, a shiny new interface.
Man is the animal that laughs.
And occasionally whores for Karma.
I think the best chance they'd have at restarting would come from the Singularity team http://research.microsoft.com/os/Singularity/
The best thing that comes from this is the following:
* Written in managed C# code
* Statically verified
* Runs in software isolated processes (SIPs)
* Excellent performance due to not needing hardware protection for buffer overruns
Just a thought. You can find it on CodePlex right now at: http://codeplex.com/singularity/