What I would do if I was in charge of Windows 8 - Miguel de Icaza
tirania.org
tirania.org
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?
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".
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.
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...
On the other hand, text files are universal.
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.
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.
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.
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.
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.
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.
http://en.wikipedia.org/wiki/Windows_Virtual_PC#Windows_XP_M...
it is only available to Windows 7 Professional,
Enterprise, and Ultimate editions
It also suffers from the overhead limitations of VMs
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 manifest approach described by Miguel could be a good compromise, but it's not immune to problems.
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.)
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).
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.
Not sure if the architecture impedance mismatch would allow it.
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.
I did know about the express versions, but in 2010
I do not want to track feature matrices for dev tools
Sun was absolutely right then they said the network is the computer. They just jumped the gun by about 20 years.
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.
- 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.
Perhaps this could become a raison d'etre for Silverlight.
I really don't like it when Microsoft decides to add a feature on the assumption that I'm an idiot.
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.
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.
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.
If the future of Windows in a controlled environment like iOS4.0, then my future leads to making Ubuntu my primary boot segment.
This sounds like a good description of Silverlight out-of-browser applications. I wonder why he didn't mention them.
If MS is worried about people using this for servers, it's easy to add limitations at a higher level.
- 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.
I thought my intentions were obvious in the post. They are also consistent with my personal history, as well as my previous posts.
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.
Edit: Also no defragmentation on OSX!
NTFS is a much more modern fs than HFS+, but that doesn't necessarily make it faster.
Edit: Just hit the NTFS article on Wikipedia, and there are a few cool things there: http://en.wikipedia.org/wiki/NTFS#Features
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.
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.
Nor modern, BTW.
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.
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.
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.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)
How many Windows users do you think would do this, or even know what it means, as a percentage of the total?
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 ;-)
Also, I always could run away with the money after mortally wounding the company.