(or: "How a Program's Features Should Start Out Simple and Become More Complex in Reponse to the User's Activities Over Time")
The current state of user interfaces
- The major failing of a lot of software seems to be that it's too complex at first -- many programs have a daunting user-interface with tons of buttons and widgets and panes and menus full of crap. The learning curve dissuades people from using it.
This makes sense, since software is supposed to save, not take time. And how do you even know if the software is going to save you time if you can't find that out until after you've wasted all this time learning how to use it?! Sometimes it's worth the time-investment to learn the software, but people will only do that when they know the software is going to save them time. Most people will just default to simpler solutions, like a pen-and-paper.
The best (or at least, the most widely used) software is elegantly simple. Look at things like google, Mac OS X, Twitter, basecamp, Notepad, etc. These programs became popular because of how easy they are to use. They have a good number of features, of course, but the trick is that they only have the most essential features. You aren't constantly inundated with unneeded buttons, for functions that you'd only use once a month, and which you keep forgetting how to use so you end up doing the task manually rathar than relearn how that feature works since it takes less time.
- The simple programs have almost no learning curve, which makes them very popular and easily accessible to casual users.
Well-designed elegant programs don't have to be used for simple things -- they can do complex things by a miraculous innovation known as manual labour. Yes, users always find clever ways of using the simple set of features to accomplish complex tasks.
Improving the interfaces
So... Obviously, software should ALWAYS start out simple. When you learn a new program (and when you read a book teaching you a new program), you always start out by learning how to use the "core" features.
Now, in a big daunting interface, there's no way you can figure out what the core features are. You have as much likelihood of finding a crazy feature that was stuck in for 1% of the users as finding a feature that you'll use 375 times a day.
So, my goal is:
A user interface that intelligently becomes more complex as the user learns the program.
This is the best of both worlds! It's easy to use at first, and incrementally introduces handy features that the user would need as they would need them. At any point in time, the user only has to learn a tiny new feature.
Now, an even crazier idea is to only have the software contain a simple set of features, but give it the ability to learn patterns in the user's behaviour, and suggest "macros" of repeated sequences of tasks. The more a user does a sequence of actions, the clearer the pattern will be. The computer can even learn what data is likely to be entered in certain fields for that task!
Yes, it sounds like a crazy idea, but I'm certain that this will be a reality in the not-too-distant future...
So, the idea is that, for the computer to be able to watch what you're doing and be able to automatically intuit patterns and classify them as "tasks", it has to have a representation of the program as some kind of symbolic or conceptual framework. For example, concepts in the program would be things like: "look up person's record", "find their credit card number", "copy the credit card number", "open the credit card number validator", "paste in the credit card number", etc. So, after doing the same set of operations about 5 or 10 times, it would be able to pick up the regularities in this activity and create a new macro or command (a contextual command which would only show up when you were in the credit card field, and it would also be able to predict when it should be shown).
Once a framework for the program's concepts has been created, automating the process is simply a matter of hooking up a back-propagating neural network with a fairly long temporal memory to all of the commands that the user enters, and having little menus pop-up which ask you whether or not you want to save these commands. So, the real challenge is in finding a good way of defining the concepts of the program.
Well, funnily enough, this is exactly the goal of Intentional Software. The Intentional Software people are developing this tool for a different reason than me; Intentional Software was invented to make the programmer's job easier, not the user's. See, programming is an incredibly complex, repetative, and labour-intensive process because, to do their job, programmers have to encode their concepts into a very different language from the one we think in, or they have to go the other way and decipher code to determine what the original programmer was thinking. Intentional Software was created to automate the process of encoding and deciphering the ideas that the programmer thinks in by allowing the programmer to create a conceptual framework for their program which would automatically generate the code for them! They write "code generators" which the Intentional Software tool uses to convert the conceptual framework into code automatically. This is a huge time-saver because, if they want to change things conceptually, all they have to do is manupulate the concepts in the framework and run the code generator!
This situation is very similar to programming back in the olden days. People used to program in assembly, which was very difficult since the language was incredibly primitive and very different from the way a programmer thinks. So, they invented high-level langauges like C and Pascal which would let you write in a language more like English, and which had compilers which would automatically generate big wads of assembly code from the language. If we were still trying to program modern software in assembly, it would be totally unmanageable. High-level languages gave us power, and I believe this is what Intentional Software will also do.
Anyhow, this Intentional Software stuff will give people the conceptual framework for free, which would allow people to very easily incorporate the learning-software idea into their programs!
Software that can learn about the quality of its learning
People's activities change over time, or they might use a completely different set of activities depending on what they're doing. For example, if your program is a drawing program, when you work on a photoedit you'll use a lot of eyedroppers and smudges and filters, where if you're working on a cartoon you'll use lots of vector tools and fills and such.
So, the software should be good at picking up on external clues to figure out what set of tasks you're likely to need. For example, the directory that you're saving files in could be a big hint (c:\photoedits\ or c:\cartoons\). Or, what time of day it is could affect it (during the work-day you work on banner ads, and at night you draw cartoons).
All of this is feasible in the future when the software's framework is higher-level, and computers have oodles of spare processing power.
Practical GUI concerns
Of course, this kind of interface wouldn't be good for every person and program. Some people wouldn't need it at all; for example, the casual users of Notepad wouldn't care. The advanced Notepad user might enjoy it when the software automatically adds a feature that, whenever it sees a file which is all on one or two lines, it replaces all the \n's in the file with \r\n's.
The optimal environment for this kind of program is a simple, manually designed interface which has only the most crucial features in it elegantly laid out. This would satisfy most people. Then, the advanced users could start adding these customizations that come from the program learning how they use it.
For the full power of a dynamically reconfigurable GUI to be practical, I think it would be necessary to based the GUI on a very flexible layout engine, like XUL or XAML. XUL and XAML give the programmer the ability to easily and completely rearrange the entire GUI -- you're not restricted to hard-coded forms, panels, and text-fields. You could create a crazy Star-Trek-like dynamic interface with one of these babies, where the whole screen can shrink down, and little buttons can appear beside it, then they can rearrange themselves automatically, and you could have fisheye icon-selectors, or whatever! (How snappy the interface will be depends heavily on the quality of the engine that renders it, of course. Avalon -- the renderer for XAML -- is probably going to be better optimized.)
The point is, with current GUI technology, a dynamically reconfigurable interface would be very awkward.