The problem with Windows is that there isn't a lot of API for very important system tasks. Instead, everything is held together by convention -- a DLL copied to the system directory, a registry key, shortcut files, etc. This has made it much harder for Microsoft to adjust Windows to better handle a much more user-hostile world. It has also made the software more brittle because they simply aren't forced to follow the convention.
For example, installing and uninstalling software is broken in Windows because there's no accounting by the operating system as to what was changed -- if an uninstaller is broken the user is pretty much stuck. If applications were forced to install themselves completely using a system API, then Windows could track the changes and simply undo them itself. This could be pretty low-level (it doesn't have to be MSI, for example) but if you want to write a file into the /Programs/ folder, you need to use an API that does just that. And if Microsoft decides to rename that folder again you are guaranteed that every application will continue to work.
This can be equally true of setting file associations, adding desktop/startmenu icons, the notification area, and auto updators. Applications have been allowed to basically spam your computer with icons and background tasks. This doesn't necessarily need to be sandboxed out of existence but instead held behind an API that empowers the user. Mobile operating systems already do much of this by asking you at install/runtime what access an application should have and then providing a system control panel for adjusting this access after the fact. Wouldn't it be great if there was a control panel that listed every background task started by Windows with the program it belongs to, a description, and the option to turn it off?
That is certainly one problem Windows has. It's also not really orthogonal (I'm looking at you, registry) and doesn't strive for simplicity or elegance like Unix/Linux tend to do. (Why the user folder is so ambiguous and mysterious before Windows 7 is beyond me.)
If Eric Raymond is to be believed, another problem is that it has no unifying concept, a la Unix's "everything is a file" or Apple's "make the GUI simple and focused".
If they had provided APIs for every function that is part of the registry, they could changed the implementation at will. Instead, the registry is just another file system with all the same problems.
Unix also suffers from the same problem of convention over API. They do have a better convention and "everything is a file" is sort of an API onto itself but the concept is pretty much gone once you reach the level of Windowing System.
"Everything is an OLE server" is the closest Microsoft concept. And it is too - files on NTFS filesystems are a lot more than just files, only (nearly) no-one uses all the fancy stuff, and it's not really exposed through Explorer or CMD. You don't really need file extensions, for example, but everyone is so used to them.
The Registry arguably is no more or less sensible than /etc full of cryptically named config files and executable scripts, all in slightly different formats...
The Registry is a pseudo file system inside the file system. It is one of the reasons that Windows is so much harder to backup and restore than Unix is, because parts of it contain system state and other parts contain configuration and the whole is mixed into one big mess.
OK, but it's not as simple as that. Man fstab-sync, for example, and you'll see that your config files can be mysteriously rewritten. Or resolv.conf being dynamically modified by DHCP. /etc is more complicated than just a directory full of text files.
This is not completely unlike the process model that Mac OS 7 had. Extensions could easily screw up the system, applications could write all over the filesystem and even damage the "System" resource file. All applications could modify all of memory.
OS X added process protection and fixed most file permissions and /System is almost read-only (some 3rd part still install stuff there). The major tool was Carbon: provide all the functionality as system calls instead of modifying lowlevel memory directly. Carbon was sourcecode backwards compatible, so you could easily modify your app and still have the same binary running on old Mac OS versions, and run on OS X at the same time.
Mac OS would have had Carbon-style protection sooner if Apple had not dreamed of Copland as the golden bullet as the future OS.
Microsoft needs to create a "Carbon" for installing and updating apps.
> Wouldn't it be great if there was a control panel that listed every background task started by Windows with the program it belongs to, a description, and the option to turn it off?
So.... `msconfig`? Ok, maybe it doesn't have all the descriptions, but it still lists all the registered services and allows you to disable them.
I've never seen anyone but a power user use msconfig and even I have to google the file names to discover what some of the stuff does. I'm thinking of something considerably more user friendly.
Self-contained installations are an absolute critical must in the evolution of Windows. It's downright embarrassing how installing even a simple app will spray files all over your filesystem diarrhea-style, making it impossible to remove (sometimes even by using the uninstaller!)
So far Apple hasn't really enforced the app-container design pattern very strictly, though I think they ought. Adobe is the most egregious violator of this - they spew files all over the MacOS filesystem and require their proprietary installer to do anything to the app.
On top of this idea is the necessity to remove the registry altogether.
For good or bad, Microsoft has committed to backwards compatibility. That means that all the techniques that work for installing apps now will work until Windows 7 is no longer supported.
My team has put a lot of effort into making our install more contained, but certain things still need to go in system locations. Registering a handler for a file extension means writing to the registry, as does (ironically) registering for visibility in the Add/Remove Programs UI.
I'm certainly jealous of the bundle system on OS X, but it doesn't solve everything. Device drivers still need to associate hardware devices with a handler, which we have to run code for on OS X.
> Registering a handler for a file extension means writing to the registry, as does (ironically) registering for visibility in the Add/Remove Programs UI
But it doesn't have to be that way. Microsoft can deprecate and replace those outdated mechanisms while still supporting them.
OS X's bundle system is indeed elegant, but it's been around for 20 years (!) and its benefits are well understood. You have to wonder how long it has to take for Microsoft (and others) to catch on.
>For good or bad, Microsoft has committed to backwards compatibility.
I wonder if they couldn't get around this by breaking compatibility on a new OS version and then running something akin to Wine to run apps for older OS versions.
They do. Sorta. It is called "Windows XP Mode" (XPM), but it has some fairly significant limitations: it is only available to Windows 7 Professional, Enterprise, and Ultimate editions. It also suffers from the overhead limitations of VMs - for instance, the video "card" is emulated so video-intensive programs suffer.
it is only available to Windows 7 Professional,
Enterprise, and Ultimate editions
That's sounds like a business issue, not a technology limitation, unless there are costs associated with it that make it impossible for them to offer it across all of the many versions.
It also suffers from the overhead limitations of VMs
OS X was in a similar situation, twice: first with the OS 9 classic environment then with Rosetta for PPC-compiled apps. Performance with each was less than ideal, but that's what was needed to move on.
That's totally different then. WINE is just an implementation of the Windows API that also sand boxes windows applications into one area. Since windows actually has their API they could pull this off much better than WINE does.
There is no earthly way that an app-store style platform for Windows would be backward compatible, but it doesn't have to be. New apps would run in a sandbox and only those would be allowed to use the slick new distribution system, go in the app store, etc. Legacy apps would run the same way they do now. Some day, there would be no more legacy apps but until then, the two types can happily coexist.
What they need is something like ".NET App Framework" that offers a complete platform in a sandbox. They could easily leverage existing Windows and .NET functionality to the point where the platform would be considerably more powerful than iOS/Android/WWW and very difficult to clone. Making it touch-friendly would be a good idea too.
This is a far better option for them than trying to clone Google's clunky web apps or start yet-another-smartphone-platform. There are really only a few critical things that allowed those models to successfully compete with the desktop, so figure out what those things are and fix them. Contrary to Microsoft gospel, the market is clearly willing to throw everything away and start from scratch, just to fix the bloody mess they made, so do it.
The problem with mandating self-contained applications is that there are some useful features associated with applications that are INHERENTLY not self-contained. Shell integration is a good example, but basically any kind of integration or shared functionality (or even data) with the system or with other applications falls in this category.
The manifest approach described by Miguel could be a good compromise, but it's not immune to problems.
Obviously no piece of software is self-contained. It has to make use of some sort of resources and interact with the user in some way. For a sandboxed platform, you carefully design the APIs to not grant any unintended privilege to apps. You can still do all sorts of fancy integration, you just do it through an airtight API.
It does that with a completion script, typically put in /etc/bash.completion.d. All scripts in this directory are sourced by /etc/bashrc. Each app provides its own completion script.
The packaging system (RPM, deb) tracks files installed anywhere on the filesystem, including ones in /etc/bash.completion.d/, and will remove all of them when the application is uninstalled. "Symlink magic", whatever that is, won't help at all.
I know that the package manager keeps track of it. I did not express myself clear enough.
> The packaging system (RPM, deb) tracks files installed anywhere on the filesystem, including ones in /etc/bash.completion.d/, and will remove all of them when the application is uninstalled. "Symlink magic", whatever that is, won't help at all.
If all the files needed for a package / program are in one place, the job of the package manager gets easier.
You might want to have a look at GoboLinux. They are trying to make the file system the package manager. (Haven't used it, yet, though. Still using a Linux with a traditional package manager.)
Installers on OS X have a manifest of files they install. I'd be surprised if MSI didn't do the same, but I guess not everyone uses MSI. On OS X most apps still leave prefs or other files around too so it's not perfect, but it's something. Tools like AppTrap can help clean up cruft when you delete apps.
I'm really surprised that nobody has mentioned App-V yet. I guess it's because of HN's bias towards developers rather than computing infrastructure types.
App-V encapsulates pretty much any Windows application. It prevents it from screwing up the system. It would be a good foundation for this app store - and it doesn't require that every app ever written is redone. It dummies out the registry and file system paths. The basics of this technology were used in Vista (and now Win7) to allow them to make major changes to filesystem structure without breaking compatibility with older apps. Microsoft bought this technology from Softricity years ago - http://www.microsoft.com/systemcenter/appv/default.mspx.
If you want to see what this could be like - look at http://spoon.net/browsers/ if you have a Windows PC. Stream apps from the Internet to run locally in an isolated execution environment. (BTW: Spoon doesn't run on App-V, it is an alternative).
I mentioned it elsewhere in this thread. There's a "Click-to-run" SKU of Office 2010 available running under App-V. It's (seriously) magical technology. Your application streams to you while you run it, application updates are completely transparent, and registry modifications are entirely within the App-V sandbox. There's some work that MS had to do to add hooks to allow Office 2010 to interact with the local system when necessary.
Yeah, I'm familiar with that click to run Office 2010. I think that is the start of App-V becoming more prevalent by default in Microsoft's own applications.
Sandboxes have some nice advantages, but I think they would need to be really careful with the implementation. Too little sandbox and they are mostly useless, too much and you end up in the Disneyland-computing that is the iPad.
Besides that, one of the defining things of Windows, for better or worse, is that applications can do anything they want if they dig hard enough and there are lots of legitimate cases for that type of application.
Would most windows users be better served if the system was more like the iPad? IT support seems to think so, and except for developers, this maybe true.
The relevant question is, "How much more like the iPad?"
If you look at the evolution of the sandboxing on the iPhone/iPad, you'll remember that the first version didn't even offer cut-and-paste between applications, and that multi-tasking is just coming now.
Granted this isn't an issue for most mainstream users, but this would put my company (Wacom) out of business. Not all input devices are keyboards or mice; not all applications can get by with only network and limited disk access. Not all computers are iPhones and iPads.
Sandboxed installation would encourage app usage a lot, so I second the idea. Here are some others
a) Microsoft seems to be the only one selling dev tools at this point. Releasing free versions of visual studio for developers would be great.
b) Have something like synaptic/ports which allows developers / users to easily install apps / libraries with dependency resolution.
c) Rethink their backward compatibility model. There is a business line of business that requires backward compatibility back to 1990, and theres a consumer line that doesnt care much about it. Right now the business line and the consumer line both hold each other back. eg business user - why do i need a graphics card to fully use new windows versions.
d) Leverage integration between the OS and their online services. I think they can do this safely now without fear of antitrust issues now given google and apples sizes
I did know about the express versions, but in 2010 I do not want to track feature matrices for dev tools (http://www.microsoft.com/visualstudio/en-us/products). Some things like test driven development and source version control are not enterprise features anymore imo, theyre required. My earlier post was not clear about this, sorry about that.
Developing software today typically requires downloading a framework or two, checkout out code from github, code.google.com etc. Often to start developing using a particular framework foo on ubuntu requires just "apt-get install foo", on windows it still involves 1990s style chasing of dependencies.
In retrospect all the features that I ask for matter mostly to developers so there is definitely a bias in what I am saying.
Moreover, even the grown-up VS is free for many students (and cheap for the rest), and with BizSpark they have a discount for startups too. I don't think dev tools are Microsoft's problem right now.
The system he describes sounds a lot like what I think web apps are going to look like in a few years. Why reinvent all this machinery for "native" apps that aren't any better for most tasks than a web app that also automatically solves the problems of backups, sharing, security, collaboration etc at the same time?
Sun was absolutely right then they said the network is the computer. They just jumped the gun by about 20 years.
Native apps are dramatically better for many tasks than web apps are or will be in the foreseeable future. This is why we have the app store(s).
And the problems you mention really aren't "automatically" solved by web architecture, they are just easier to solve. However, there's nothing about native apps that make those problems particularly difficult, if you're willing to use a modern platform and ditch the legacy stuff.
Meanwhile, the web has already built its own substantial mountain of legacy junk.
I assure you that a web app doesn't automatically solve the problem of backups etc. It merely moves it to someone/somewhere else. But then, so did IBM 3270 back in the 1970s!
There's one thing that made it a hit for Apple that I'd like to see Microsoft emulate - Simplicity. If they can make it simple for the end user as well as the developer this will take off and be very useful.
This should work well, but need lot of work from the Microsoft and other parties part:
- Microsoft create a development environment as powerful as Visual Studio. You create "native" Windows applications that has full but controlled access to disk files, system resources, Internet connection...
- Application are native in a way they integrate nicely in the sidebar, menu, have nice graphics and animations...
- Type of these apps can be for example "Drop Box"
- Microsoft build an online app store and a desktop app store app. where users can download, purchase, rate and review apps.
As a user, I browse apps and select the one that fits the need. The app should blend with my Windows theme, be user friendly and fast.
Considering the huge number of Windows users this can turn into a multi-billion dollar market. This will especially make decent profit for single developers.
>Microsoft create a development environment as powerful as Visual Studio. You create "native" Windows applications that has full but controlled access to disk files, system resources, Internet connection...
Perhaps this could become a raison d'etre for Silverlight.
Windows is currently all things to all people. But that assumes that all users have the same needs and they don't. Most users struggle daily with stuff that we take completely for granted.
I too hate it when Microsoft adds a feature that assumes I'm an idiot. Every time I install Windows I have to go through the configuration dance to get it to "power user" settings. By default, it's not setup for you or me. It's not really setup for the average user either -- it's somewhere in the middle.
Exactly. Every new windows system takes me about 2 days to set up. Every default seems to be wrong, so I spend so much time rediscovering how to change it again.
On Mac I'm set up in an hour or two. Either the default is right, quick to change, or too much trouble to change to be worth the bother.
Not to be the Linux fanboy, but with Ubuntu, I am usually set up in 20 minutes and up-to-date in 30, if the bandwidth is nice.
I am considering building a metapackage just for me, rbanffy-desktop, to set up eveything on my box automagically upon invoking "aptitude install rbanffy-desktop" (or selecting it from the GUI installer). That way I would be up and running before I am back from lunch. Maybe I will need two, rbanffy-repos to set up 3rd party repos (VirtualBox, Skype, Google, PPAs) and one to do the heavy-lifting. Sounds like a good fun project.
Really? For me Linux takes days. Longer than Windows. Given that it's much more customizable than the other two I spend a lot of time setting up everything how I want.
You can tweak it for years if you want, but that doesn't mean you can't start working after a couple minutes. The point is a Windows box takes a full day to set up. You can somehow reduce that by slipstreaming SPs and fixes into the install disk, but keeping track of them and merging them into an install disk is a career in itself (one I would chose crime over)
That's why it would need to be something new. Right now we have the "big pool" where you can have as much fun as you want, but you can also drown and there aren't lifeguards to help you out. What we also need is a "kiddie pool" where the water is shallow and safe. I don't think he's advocating for replacing the big pool with the kiddie pool. He just wants this AppStore that would allow regular folks to install / uninstall apps without the fear of messing up their system. A rewrite of the OS to prevent apps from doing what they want would break a ton of existing app -- that just won't fly. But, a "new type" of app, something that's safe and you install from the AppStore...
Wait, are you being sarcastic? Whenever I use Windows I feel like it's trying to hold my hand the whole time (you have unused icons on your desktop!) and won't let me do basic things like setting up a custom backup script or picking a different window manager.
Bingo! I wanted comment this exact same thing. I use Windows because I want to control what I do, not let someone else control things, like I have with my iPad and iPhone.
If the future of Windows in a controlled environment like iOS4.0, then my future leads to making Ubuntu my primary boot segment.
Isn't there already sandboxing for registry stuff in Windows 7? I really haven't followed it closely but I seem to remember reading that they give fake directories and registries to applications. So they think they mess with the real thing, but they really don't.
- change terms for OEM licensees so that they wouldn't be penalized for selling machines with other OSs or without OSs
- remove limitations on hardware on licensing for netbooks, thus removing performance and specification limits that kept those machines less powerful than they could be
- bundle IE 9 and pressure it into standard compliance
- remove any IE-specific HTML rendering code in the user interfaces so that the user could replace the HTML rendering engine with any other engine that implemented the same, clearly defined, public interfaces
- publish all interfaces for HTML rendering and JavaScript execution so that third parties would be able to provide plug-ins to replace or use those services interchangeably
- publish a list of all patents Linux and other notable free software projects may infringe and work with the community on solving the issues, perhaps entering a cross-licensing agreement with the Open Invention Network and donating patents to their pool
- adopt a modern file system, perhaps licencing ZFS from Sun and replacing NTFS
I guess being in charge of Windows 8 would not be enough, but it could be a start.
None of these things would help Microsoft at all. Basically, what you'd do is run Windows 8 for the benefit of all of Microsoft's competitors. That might be noble, but it's pretty dumb.
>- adopt a modern file system, perhaps licencing ZFS from Sun and replacing NTFS
Long time windows and Linux user, recently bought a macbook. The first thing I noticed is how smooth application running is (mine doesn't have SSD). In windows you can actually "feel" an application opening or when you are doing search for files. Nothing like that on Mac/OSX. I wonder if it has something to do with the file system. I have been told that NTFS is supposedly a superior file system than HFS+. I have no idea if its true or not.
I'm curious what you feel makes NTFS more modern than HFS+. From all the documentation I've read, they seem fairly comparable in terms of feature sets (extents, fine-grained ACLs, etc) and both seem pretty modern, but there may be 'under the hood' implementation details I'm not familiar with.
My favourite example is filesystem transactions, so that you can group sets of changes into a transaction, then roll back or commit in the future (e.g. if you overwrite a DLL at the start of an installation, but then you can't overwrite another one later, you roll back the transaction). I've been wanting this in OSes for years.
Single-instance storage - the system inspects two sets of files (e.g. installation images on a network server), and if it finds identical files, it 'consolidates' them on disk. The two files are still different (if you change one, only one changes), but as long as they're identical it conserves disk space.
User-transparent on-disk encryption
Volume shadow copy (which I knew about already)
The USN Journal tracks all changes made to anything on the disk; it's similar, in a way, to OS X's filesystem access hooks, but not quite.
Yeah, NTFS is an excellent filesystem. Unfortunately many of its features such as streams and reparse points are rarely used.
Besides, you have to compare like with like. When NTFS was introduced, most Unix systems were still on something like UFS. If you wanted a journalled filesystem back then (and weren't on IRIX), you had to pay cash for VxFS.
To the one who modded this down possibly because of the idea that NTFS is "modern" (of HFS+, BTW): list one feature of NTFS that hasn't been around in other filesystems for 5 years or more.
fragmentation prevention? OS/2's HPFS had that
long file names? Apple's DOS 3.2 had them (up to 33 chars)
journaling? ext3 had it, for both data and metadata
symlinks and hardlinks? Unixes had them since the beginning of time
multiple forks: more a bug than a feature. Macs MFS had it.
I think what you're "feeling" is a simple matter of disconnecting your UI thread from the "do stuff" thread. It's not the waiting that aggravates us most, it's the fact that the waiting bits drastically slow down, if not disable our ability to do other things in the meantime.
I think you are right. If I have several application minimized under windows and I try to go back to one app after few hours it not only takes a long time to maximize its stop everything else from working. The performance get worse as you use your computer longer. I remember my fresh window7 install was a nice change over vista but it has gone worse in last few months and it gets slightly better every time I defrag HD and register, it gets worse again after few weeks/months.
This never happens on OSX. They are obviously doing something right.
OS X will still fragment large files - they don't fit in the catalog so HFS+ compression won't work on them (not that it works on user files anyway), and the auto-defragmenter only works on small things.
The difference is Apple doesn't ship a defragmenter, so you don't care. I think this solution would work just as well for MS.
With HFS+ on OS X, whenever the operating system accesses a fragmented file under 20 MB, it checks to see if there is a large enough contiguous block of free space elsewhere on the disk to defragment it to; if there is, it silently moves it.
Thus, you're almost guaranteed to never have fragmented files under 20MB (unless your disk is a complete mess). Above 20MB, you typically don't get significant fragmentation until your drive is nearly full and the system has to pick and choose free space blocks from all over.
I'd really like to know what is so unHN-like about my post. Maybe my information is wrong and/or outdated, but I was just presenting the information that I had, hoping it would further discussion and/or be useful to someone.
Sorry, just something I remember reading in a forum post a while ago. I think that forum may have been Slashdot. The gist of it being that the original specs made room for a lot of features that Windows didn't support at the time, and Windows has slowly been adding them as time moves along (i.e. hardlinks, symlinks, etc).
The closest I can come on Wikipedia is:
> It is also clear that NTFS owes some of its
> architectural design to Files-11 used by VMS.
> This is hardly surprising since Dave Cutler was
> the main lead for both VMS and Windows NT.
No. My windows 7 is a quad-core desktop with 4GB memory. My macbook is a dual-core with 2GB memory. I don't mean to say that I don't get the occasional beach-balling and slow app start time, but generally speaking much more responsive than windows 7.
Still, ZFS sports adjustable redundancy, checksumming to prevent silent corruption, block-level deduplication, zero-cost snapshots and lots of other niceties neither HFS+ nor NTFS support such things.
BTW, BtrFS on top of LVM will support a lot of that too, as soon as it gets ready, something I suspect it's not. It also sports better disk allocation method (blocks and extents vs. slabs). It would be really nice if Oracle decided to merge both filesystems (or, at least, the feature-sets)
> - remove any IE-specific HTML rendering code in the user interfaces so that the user could replace the HTML rendering engine with any other engine that implemented the same, clearly defined, public interfaces
How many Windows users do you think would do this, or even know what it means, as a percentage of the total?
The system should be completely modular. HTML rendering should be a service and any provider should be able to plug into the service infrastructure to provide it.
I imagine faster engines could be easily developed by the market, provided there is the opportunity for competition. Companies could also roll-out in-house developed, specific components that would plug into the system and provide added/reduced functionality in accordance to their needs.
Of course, that would sabotage the whole standard lock-in Microsoft employs to retain market share. I don't care. That's what I would do. And that's probably why Microsoft would never hire me ;-)
For example, installing and uninstalling software is broken in Windows because there's no accounting by the operating system as to what was changed -- if an uninstaller is broken the user is pretty much stuck. If applications were forced to install themselves completely using a system API, then Windows could track the changes and simply undo them itself. This could be pretty low-level (it doesn't have to be MSI, for example) but if you want to write a file into the /Programs/ folder, you need to use an API that does just that. And if Microsoft decides to rename that folder again you are guaranteed that every application will continue to work.
This can be equally true of setting file associations, adding desktop/startmenu icons, the notification area, and auto updators. Applications have been allowed to basically spam your computer with icons and background tasks. This doesn't necessarily need to be sandboxed out of existence but instead held behind an API that empowers the user. Mobile operating systems already do much of this by asking you at install/runtime what access an application should have and then providing a system control panel for adjusting this access after the fact. Wouldn't it be great if there was a control panel that listed every background task started by Windows with the program it belongs to, a description, and the option to turn it off?