Is the modern operating system a tool of facilitation that should provide just the basic necessities of a system and no more, staying out of the way of the user? Or should the modern OS assist the user in their everyday tasks, sorting and displaying relevant information, providing a filter between the ever increasing amount of information and the task at hand.
Even the most sophisticated OS’s currently available are no more aware of the actions and intent of the user than an OS ten years ago. Better technology and programming have provided us with more elegant, graphical, and functional systems, more capable of handling and processing our data in the desired manner without crashing or corrupting our files, but for the most part this is taken care of by the individual pieces of software using system resources doled out by the system kernel. A computer running a modern OS may be able to simultaneously run hundreds if not thousands of threads, which the user has come to expect, but besides a table of currently running threads and system resource blocks, the OS is not really aware of what programs are running, and is incapable of easily facilitating the filtering of data. But why should it be? Because an OS that is aware of the current and past states of the system is better able to determine how to exchange, present, sort, and display data to the user depending upon what, where, when and how the user is using the computer.
Before you jump straight to the idea of an annoying talking paper-clip assistant on the operating system level, telling you which files you are trying to access and offering you alternative methods of formating your data, let’s look at how systems are already beginning to show a shift towards predictive computing, and explore some concepts that are not yet implemented, but would appear to be immediately beneficial.
The loading of program resources at the beginning of a user session or at the startup of a system is a move towards a predictive OS that tries to anticipate what programs and files the user will need during their work session. Most current Operating Systems have some method of preloading resources or programs, such as the Startup folder in Windows, and almost all of them fall short of being truly predictive. The startup folders tend to be controlled by individual programs instead of being controlled by the operating system, and what could be a very useful predictive tool becomes a means of jockeying for file associations or user time, as is evident in the constant reassignment and reclamation of media file types by a range of different media programs like Real Player, Windows Media Player, and Quicktime. While this is more prevalent on different Operating Systems it is an obstacle to be aware of for any system that attempts to implement predictive resource loading.
A more successful example of predictive computing that is becoming more common among applications and Operating Systems is the inclusion of Recently Used Files listings. In individual applications the list of most recently accessed files makes management of any multi file project easier, but on the Operating System level Recent File lists can be useful and extremely distracting at the same time. When confined to a single application it is usually quite obvious that you will be working on a file of a type associated with that program, so the Recently Used File listing inside the program is something of a no-brainer. But on the OS level, when the number of commonly used programs is in the double digits, the number of file types accessed is equally high, and the number of individual documents accessed can reach into the hundreds, simple lists of the most commonly accessed files, or the most recently accessed programs seem archaic and misguided.
So how can you improve the Recent Files and Recent Programs on an OS level to reflect the usefulness of the Recent File list in an application? One of the answers is quite simple, and opens the way to more predictive practices that could be incorporated into current or future Operating Systems to change the way we work and play on our computers. The easiest list to address is the Recent Files list. The first step to a more predictive listing is to apply filters to the types of files being listed at any given time depending upon the currently open or active programs. Filtering the content of the file listings in this manner is a great step towards improving the utility of the Recent File List. Additionally groups of files in different directories can be included and excluded from the file list depending upon the time of day, according to either preset filters defined by the user or behaviors learned by the OS itself.
Some of the same techniques can be applied to Recent Programs listings, but a few modifications are necessary. While it may make sense to filter the list of recent or commonly used programs by the current time of day, filtering the list according to the currently active programs must take a different form than it did for the Recent Files list. The ability to set a series of rules guiding the available programs on the Recent Programs list could be incorporated into an OS through the analysis of patterns of application use. For instance: The majority of the time that I open a document editor and an email program, I also end up opening one of three different Internet browsers. Once an OS has learned patterns of this sort (commonly known as Markov Chains) it has the ability to analyze the currently active applications and fill the Recent Programs list with programs that I would commonly use in association with what I am already doing, eliminating from the list programs that I never open in conjunction with what I am working on at the moment.
These additions to the Recent lists are theoretically simple enough to add onto existing Operating Systems without having to significantly alter any facet of the system. In fact most of the additions so far could be patched onto an OS through a constantly running background application. But the model of behavior prediction explored so far can be extended to include more than lists of common files and programs, and if incorporated at the OS level can influence user habits and efficiency throughout the system.
The aforementioned behavior prediction systems could be easily added to an OS that incorporated behavior analysis and modeling at the system level, keeping track of all user interaction with the system and individual programs, constantly recording statistics and actions to build a profile of typical user behavior patterns. The behavior patterns are not a set series of steps, rather a large set of behavior sets and small patterns that are constantly analyzed against the current user behavior. And to what end? By building a ‘memory’ of how the user interacts with the system it is possible to incorporate into the system a number of immediately relevant functions to improve how the user interacts with the computer, and how the computer reacts to the user.
Using predictive patterns it would be possible to implement an intelligent version of the system Startup folder; rather than open a number of random programs at the beginning of a session depending upon which programs have added themselves to the startup sequence, a predictive system could determine at any point during a user session that a certain program or system resource is probably necessary in the imminent future, and begin preloading the resource in response.
Predictive modeling of future user actions can also help prevent the user, or unauthorized users, from harming the system. By tracking user interactions with the system and comparing them with a known set of behavior patterns the system can attempt to determine when an unauthorized user is trying to use the computer, as this person’s use patterns will more often than not vary from the normal user or users. This is not a new concept in system security, but when implemented on the system level can provide a much better profile of user behavior, and can monitor computer use as part of the system kernel. In addition to preventing unauthorized use the predictive system could monitor when authorized users begin to venture beyond their normal behavior patterns, and provide sufficient system warnings to the user alerting them to potentially dangerous commands or actions.
Once a predictive system has begun to learn the typical behavior patterns of a user it can aid the user in highlighting or ignoring different programs and system messages depending upon prior observed patterns, and the current behaviors of the user. Take, for example, a user who watches DVDs on their desktop computer. While watching a DVD the user receives a not too critical message from a program running in the background, which pops up in front of the movie. The user, quite annoyed, quickly closes the notice and returns to the movie. The predictive system would record this reaction as part of the normal analysis of user behavior, and would begin to block non-critical messages from that background program while the user has DVD software open on the desktop. Many such links between programs and events can be thought of in just a few minutes, and many more would begin to emerge for various users as the predictive system analysis their typical behavior. Any system of this type would need to be flexible, constantly updating and altering it’s rules and settings as it builds and rebuilds the map of user behavior.
These ideas are only intended to further the exploration of what new and current Operating Systems could evolve into when we think about giving the system the chance to help the user. As we know from any existing OS, one method is not the answer for everyone. While some people would benefit from and enjoy the experience of a highly interactive and predictive system, others would be insulted by the slightest appearance of the system trying to analyze their behavior. As with any system, a predictive operating system needs variable levels of analysis and interaction. These ideas are not written in stone, and the actual mechanisms of implementation are purposefully not discussed, as that can often lead to abandonment of exploration in favor of technical detail. But in light of the number of OS’s under development, both commercially and independently, this is a prime time to discuss how future versions of any OS could become more aware of the user, and begin to aid the user as well as the application.
About the Author:
A long time programmer and computer user, Patrick Dwyer is a Graduate Student at the Interactive Telecommunications Program at New York University. Besides exploring the possibilities of future Operating Systems, Patrick works with system level electronics, robotics, and software design.
While mostly when I log on I almost always start off by load mozilla and irc, connect to the net, and visit a few news sites(including osnews and slashdot). Other times I want to code, and that means not distracting myself with moz or tech articles. What I am trying to say, is that this system, while very cool, and useful, must not push to hard to load the predicted programs.
This was the flaw of clippy, he can be helpful, but when you want him to leave you alone, he doesn’t. This system needs to be able to leave you alone and not assume that after logging on the same process will not ALWAYS occur.
If I look as OSes like Windows and Linux, I see a lot of heteregenous components not able, for most, to communicate between themselves and users having to find tricks for making them communicating.
I think that the next step of OS evolution is normalization through a lot of standards for getting really compatible components, inside or outside the computer. Ergonomics will be significantly improved from the cooperation of system components.
Yet, standardization does not mean immobility. Indeed, we really need a stable and consistant platform in order to forward.
I think this is a waste of code. Programmers should rather think about how their program might p*** off users by having a user-interface that sucks. This is what drove me off Win98 a few years ago, honestly. Newer systems (or other ones) like Gnome, WinXP, BeOS provide the same functionality, but don’t get in the way (though XP stole a lot of its good UI stuff from MacOS, BeOS or Gnome, seemingly; they had them years earlier). This is how it should be. I don’t want dialogs popping up while watching movies in the first place, so someone should code it like that, and so on.
Apps that want to provide a last_used_items list can do that, which I like as well, but the system should be fast and quiet.
Nice article. While the points that author emphasises are correct, the behavior pattern varies significantly across different type of home-users, Programmers, SystemAdmins etc. It is very difficult to gauge the patterns for these different sets of user and if its implemented make the OS bloated and down in performance. This is a bad compromise to almost all of the users. The behavior pattern changes according to the mood and situation. (Sometimes, I wont go into a XSession and the console is simple enough for me to finish my work)
The applications that run on the OS can make this possible to some extent only and their domain very restricted to the areas they work.
IMHO the futuristic OSes will try to make strides in those areas. The OS can know the mood of the user through some touch/sensing devices and over a period of time, it can make a list of choices for that particular user and help him/her the next time.
> Ergonomics will be significantly improved from the
> cooperation of system components.
AmigaOS’ ARexx scripting did a beautiful job here… I wonder why a similar concept failed to surface in Linux.
(Windows simply has no culture of implementing, documenting and using cross-application interfaces. I don’t know about the Mac; I heard about AppleScript but can’t judge.)
My guess is: Another case of we-cannot-agree-on-one. In many areas, Linux provides so many alternatives that they get in the way. (Can you say Gnome / KDE?) If you are writing a Linux app, how would you provide a simple scripting interface to the user / developer?
On the Amiga, either your application did not support scripting, or it did offer an ARexx port, period. If you were interested in scripting, you learned ARexx, and you were able to address all applications and make them cooperate.
I am all for choice and everything, but Linux simply shoots itself into the foot here (again).
I’m in favour of the dum machine. Personally, a machine that waits for input and reacts accordingly is the machine that I prefer. Whenever I’ve used a program that makes assumptions on what it should do, it has always annoyed me.
Something like an “intelligent os” can only be implemented if the software was truly intelligent, almost AI like, otherwise it’s going to fail too many times and, with computers, people tend to notice failures and not successes.
This applies to interactive machines more so than non-interactive machines. If there’s a machine sitting in a corner and I’m not supposed to touch it, then the smarter it is, the happier I would be because I wouldn’t have to look after it.
I’m not sure if I’m being biased here. Perhaps people do want this. The need for such a system will have to be determined.
I’m sick of all this GUI crap going on today. Hardly anybody seems to still know the pure and raw power of the UNIX shell. Take a few standard small utilities, throw in some pipes, and heck, maybe a perl script, and you can do _anything_!
There’s _no_ GUI interface that can do such a variety of complex tasks in such a powerful manner as the UNIX shell.
Agreed, it takes a little time to learn, but you can save yourselfs hours afterwards, and above all: it’s blazingly _fast_ (can’t say that about most GUI’s today…)
I do use X, with a minimalist windowmanager, just because I like to be able to see images with my minimalist browser, and I like to have a dozen of xterms open and easily copy/paste between them.
I say, keep GUI’s to a minimum, only for apps that _really_ need them, and make them small, undisturbing and fast.
I should do a benchmark of KDE vs. Blackbox one day; I bet it’s about a 20x speed difference… And I don’t give a *** about these extra features (like blocking my soundcard with that artsd-crap, and gnome isn’t any better, it’s just called esd there :p)
All I want is an OS which is intelligent enough to realize that when I am typing in one text box I don’t want another window opening up and grabbing the focus!
Apart from that having a system “recent files” which simply groups recently used files according to type or project would be handy, unintrusive, and easy enough to implement.
I tend to agree.
Let’s have a look at what this “Intelligent OS” is aimed to achieve:
– being faster by e.g. pre-loading application ressources. Well… I’d daresay the computers today have all the CPU power they need to deliver the things the user wants. The problem is that current OS and applications deliver so many things the user does *not* want. I mean, how come my Athlon 1200 doesn’t “feel” any more responsive than my 50 MHz Amiga? Answer: Because my OS tries to be so smart…
– being somewhat “precognitive” about my needs. That’s the category the interactive menus in MS Office belong to: Most used menu items to the top. I don’t know about you lot here, but I always turn that off because it requires me to consciously *read* the menu items instead of just hitting the long word just below the short word in the second group of items after I got used to the menu layout.
The only solution to the second problem would be making the system yet smarter, which only makes the first problem even more troublesome.
I think people are down the wrong road here. Don’t make systems more complex, make them *simpler*. And before you think about AI, try to get the basics done: Responsive and intuitive UI, reliable and failsafe installation / uninstallation etc. etc.
But that’s the problem: Working on those features is boring, probably breaks existing code and doesn’t sell as well as some real smart AI no-one really needs…
> Hardly anybody seems to still know the pure and raw
> power of the UNIX shell.
Well, to make this a fruitful discussion I will just forget you said “UNIX” and assume you talk about a powerful and intuitive and user-friendly and consistent shell interface… 😉
I agree that a powerful shell has its virtues for the power user. But *you* seem to have forgotten that the generic Joe Average does three things: word processing, mail, browsing. If your answer to this is LaTeX, mutt, and lynx, you are screwed.
The GUI for the beginner. The shell for the power user. Both have their place, and even the power user might enjoy a GUI for apps that are actually harder in the shell. (Ever tried to create a flowchart with shell tools?)
One of the biggest things that I think annoy users and coders alike is software bugs. It would probably be wrong if it could be done to completely take away the job of programming from people but maybe software such as genetic algorithms could be incorporated into operating systems to automatically make patches and test them if a program crashed or the user could have some interface to it so as to notify it of a fault. The problem here is how would the system provide consistency on all instances of the application that it fixed. It might need to have a way of communicating all fixes from all individual machines so as they would all be acting together at least in a particular instance like one paralell computer and also to get the go ahead from the original developer. This would be important in the case of copyrighted software. Opensource software would be more easily dealt with by this system.
Greg, I don’t think your ever going to see that.
There are two basic and rather huge problems with this idea..
Firstly your system must detect the bug in the first place, bear in mind that many bugs are internal to a program and never cause the system as a whole any problems, no crashes, no system errors, it just doesn’t do what you want. Also crashes are sometimes the result of more than one element misbehaving, or a whole chain of events, which will be even harder to track down.
Secondly even if we assume that we are only talking about those bugs that actually affect the system, and are due to one program doing something well out of order. How the hell are you going to automatically patch them? To patch the bug would require not only that the system knows what happened (e.g. wrote to the wrong bit of memory), but also what was supposed to happen (e.g. it was supposed to be writing to memory address X).
Finding and fixing bugs is a large part of a programmer’s job, and a very boring part (I’m doing it right now, it gets in the way of writing code I want to write, but it has to be done). There are a number of clever, useful (and often very expensive) tools to help in finding them, but noone has yet come up with a way of automatically fixing them. To fix a bug requires knowledge of the intended functionality.
One of Apple’s selling points for OS X is that it ‘leave’s you alone’. No balloon pop-ups, no activation, serial number checks, etc. I know that is not quite what we are talking about here, but it seems to me that the user wants a transparent OS. The one feature in Windows that is like this intelligent OS is the Intelligent start menu. I don’t know anyone who likes this. At work, people complain they are missing items on their MS word menus because they don’t use them often enough, so word hides them.
I am not saying these features should not be implemented, but they should give the option to be turned off at the first instance the user realises they are present. Maybe then windows will stop asking me if I would like to remove unused desktop icons.
The funny thing is that all the example and request above has nothing to do with the operting system as such, but is for the user space programs to handle. Operating systems should not have a Most Recently Used Document/Program option that’s for the the user space programs to handle, people today forget what an OS is and think it’s every thing including the UI they are looking at its NOT. Nevertheless the discussion of intelligent user space programs is still interesting and is something software developers should look at in the future.
What has been discussed in this article is merely a few ideas for OS design and as valid as they may be, the developer community has far greater issues. Security is the primary one. I believe that 40%-50% of the money made in I.T over the next 4-5 years will be made in this field. A core requirement of this added security is a widely accepted versioning system. In addition to making installing/upgrading/removing software a whole lot easier, it will drastically reduce the number of security breaches in existance because of incompatible versions of particular software.
Never the less, a reasonably interesting article all the same.
> people today forget what an OS is and think it’s every
> thing including the UI they are looking at its NOT.
Well, that is still argued about. While the separation is very clear for e.g. Linux being the kernel and the UI being handled by X / WindowManager, it is certainly not as easy for Windows, where parts of the UI actually reside in kernel space AFAIK. (Allowing Windows to boost scheduling priority of threads that have UI messages waiting to be processed. According to Nehmer/Sturm, “Systemsoftware”.)
Unless you set OS <=> kernel (space), the discussion what is part of the OS and what is not can take you ages.
IMHO, an OS is the sum of all the things that are *defined* by the OS.
Linux does not *define* how the UI looks like or which shell you have to use, but it does *define* that drivers are running in kernel space and that additional drives are all mounted to a single root “/”.
Windows does not *define* that your office suite must be MS Office (yet 😉 ), but it does *define* how the UI works and that drives are given one-letter names.
Then again, in the end it is the overall user experience that makes up an OS, since users neither care for user vs. kernel space nor for what is “defined” or not, but just how the applications they use behave.
i said something like that some days ago talking about the “rewindable desktop”, i think it will be useful to have a system that knows what you like, but it shouldn’t be intrusive, the ideal is something like the star trek computer, just say “locate cmdr Data” and the computer takes all the steps to accomplish the command, you should just say “read os news” and the pc should know that your favourite browser is mozilla, it should use the best connection available at the moment and so on. I know you can do it right now “programming” the pc to do that, the difference is that the computer should learn by himself that your favourite browser is mozilla and other stuff…
Personally it ticks me off to have all sorts of Application launching bars and bells and whistles clutterng up my OS,
I can do a fine job at anticipating my own needs. I would rather system reasources went to work running things effciently, instead of hording CPU Cycles for extra running code.
Hardly anybody seems to still know the pure and raw power of the UNIX shell. Take a few standard small utilities, throw in some pipes, and heck, maybe a perl script, and you can do _anything_!>>
Except if you’re like me and have a real talent for transposing or omitting letters when typing or writing. (I read 1200wpm with 97% comprehension, but spelling correctly is a task.)
Command lines and keyboard driven commands are powerful, yes. (How fondly I remember hozing reams of data with a few misplaced key strokes or inserting a new margin and not realizing it until too late!)
But as a pesonr with a real talent for transposing or omitting letters, I’ll take the GUI.
I need intelligent OS about as much as I need my fridge to connect to the Net. In other words – not at all! This is just a typical example of solution looking for a problem… I want my OS to be OBEDIENT and PREDICTABLE, not INTELLIGENT, and those qualities are contradictory – intelligence implies a degree of disobedience and unpredictability. I’m not talking about some AI revolt, but even simple second-guessing of my needs is just as likely to get in the way as it is to actually help… No, thanks – like someone said earlier, I can do adequate job anticipating my own needs, thank you very much…
When a person goes to a dentist to get there teeth seen to a dentist usaully has an asistant that may be told by the dentist what he is going to do an if they are new on the job what he needs for the job to be done. After some time depending on the asistant they don’t have to be told exactly what instruments or preparations are needed only what the dentist is going to do. The asistant learns to catagorize the particular instruments and preparations according to the intention and the asistant can be very helpful and not get in the way. Why not the same for computers?
It seems that from the start when implementations like this have been tried with computers the software is trying to guess the user needs instead of the user giving some input to there intention and needs.
Even this type of thing if it was accomplished in som operating systems might bloat and slow them down but in operating systems like Beos it might work quite well. I am not an expert on operating systems but I have tried Windows, Linux, and Beos. Linux and Windows seem to need a great amount of RAM memory usage while Beos much less for similar types of tasks. The funny thing is Linux seems to need even more than windows on the two different machines I have used. One old and one quite new.
As far as Genetic Algorithm software is concerned it is aparant that software can be designed by software. Not only that but many other things designed which is either equal to humann designed or superior. This might seem frightening but it seems to exist and could also be very helpful. It seems to me that unless people get to know about it and use it early as it can be that if left alone someone will/may use it later on for making a quick buck or suck like. So responsible programmers and others ought to get to know it and use it before the others step in.