- Not mouse dependant: I don't like to switch from keyboard to mouse and back often. I would like to see better use of the keyboard in graphical interfaces.
- Minimalistic, yet eye-candy design: Some strides have recently been made in this direction.
- "Advanced" window management: And I don't mean live previews or transparency - details below.
- Filesystem changes: Isn't it about time we used some of the knowledge painstakingly gained in the last few decades?
I shall now describe some of the "features" I would enjoy seeing.
1. Getting rid of icons and shortcuts
Desktop icons and shortcuts are old-fashioned. They provide (at the same time) both too little information and too much information. Too much information because of various "document preview" features around, which attempt to render a representation of the contents into a small image. Try to distill a movie (or better yet, a song) into a 64x64 icon and see how well you do. Similar for text documents.
And even as we get richer, bigger and nicer-looking icons, all we learn from them is that it's a video/music/picture/document/text file and its name.
"But how will I launch my programs then?"
Simple: Take a look at the dock in Apple operating systems or the new Start Menu in Windows. Type in a few letters of the program name and get a (short) list of matching items.
"But what if I can't remember the program name?"
Either: a) include description in search database, or: b) fall back on some form of menu structure.
Frequently used list also helps.
"How about my documents?"
Similar principles as above.
2. "Advanced" Window manager
A lot can be said in this topic, but I will limit myself to a few examples of usability features that I, personally, would like to see.
Window positioning: When I start a new application, I would like it's window to open a little more intelligently than "where it was the last time". If the desktop is empty (ie: starting the first application of the day, or having minimized everything else), the new window should open maximized on the primary monitor. If there are other things happening, the window should open somewhere "out of the way" - below everything else, on a secondary monitor, in a large free area on the desktop, etc. The rules for determining whether I want the window to pop up in the center or not are relatively simple:
- Did I wait for the application to open or did I immediately click somewhere else?
- Am I continuing my work in another window while the new application is loading?
- Did I minimize a lot of stuff before starting the new app?
- How did I use the app previously? Did I switch to it immediately as it loaded, or did I leave it in the background for a while?
One of the key problems right now is "focus stealing" - Windows that open while I am doing something else tend to take keyboard and mouse focus and thus disrupt my work.
Message queue: I don't like flashing (or shaking, or blinking, or noisy) windows and buttons. If a background program needs my attention, I don't want it to flash in an annoying color until I click it - because it distracts me and I end up switching to it _immediately_, disrupting my work. Flashing and similar should be used only for ground-breaking-world-shattering-computer-on-fire emergencies. Nothing else. Windows which have important information for me should put themselves into a line - queue - which I can check periodically to see if there is anything new. The order could be based on time of the message with possible added priority. The queue would look like small live-previews (or program icons) in a nice bar, which could be configured to be always visible or hidden under a small icon, which would change unobtrusively when it had something to say.
In short, I would like to think along this pattern:
"Hmm, I wonder if anything new has happened to my programs, lemme look in this corner.."
rather than:
"I just finish typing this-... *ding* WTF?! Why did [insert app name] jump at me just now?!?"
Window work stacks: I often have to open a bunch of windows related to a task, perform a series of steps in each of them and then close them. A nice example is setting up a classroom of computers - installing new software.
So I am able to start all the computers via script and copy the files to them over the network with another script, but as the installation is only a few steps I am too lazy to script that too and decide to "click it through". So I open a bunch of VNC connections and start clicking through the installation on each machine. I go a few steps at a time, because sometimes software takes a while to install and I don't like to wait on it while I could be setting up another installation somewhere else.
At the moment what happens is: I start a lot of VNC windows and begin the installation process in the first one. While waiting for something to finish, I switch to the second window and start the installation there as well. So on till about the fourth of fifth computer, which has a "Pendind restart because of updates". It needs to be restarted before I can install anything on it, so I initiate the shutdown and move on. This usually happens on a few more computers.
While they restart, I finish the first install steps on most computers and start the finalization steps on the first few. Meanwhile, the restarts are done and I start the first installation steps on the newly restarted computers. But whoops, one of them needs a component that somehow wasn't installed over the domain group policy, so I need to do that before installing the program. Meanwhile, the rest of the computers have finished installation and need finalization steps, while the first few computers need testing to check if the new application is adequately installed.
Let me see you try and keep in mind the states and progress of ~20 machines while performing approximately the same tasks on them.
Solution? Window stacks. Create a "dock", "area", "margin", "however-you-wanna-callit" on a part of the screen and designate a few "piles" (Init, Prereq, Progress, Final, Test). The names would be chosen by the user when he creates the stacks. Use all the VNC windows in maximized mode and simply when a part of the steps are done "throw" the window into one of the piles appropriately. When you're out of windows, click on one of the piles to get a small preview of everything that's in it, pull out one of the windows and continue - from the pile name you know exactly where in the process that particular window is and where it should end up after you are done.
I am sure you can come up with many examples of where such dynamic distinctions would come in handy.
Meta (database) filesystem: DBFS is nothing new, the idea has been around since 1998 (as far as I am able to determine from various published papers). A short description:
Use a flat file space (all files in one directory - the root of the filesystem) and use descriptive metadata tags to enable fast and easy searching among the files. Some of the tags would be appended by the operating system automatically, such as:
- Date created, modified, used
- File type (image, sound, etc)
- If image, sound or movie, tags for specific codecs used
- Author/user
- Source (from URL address, USB key, CD,...)
- Operation flags (Executable, library, cache, index, readonly...)
- Associated program name (so it's easy to find all files related to a program)
- Opens with "program"
Additionally, the user could enter pre-defined tags, such as:
- If image: where was it taken, who is on it, name of the event
- Documents: Title, summary..
- (more depending on file type)
On top of all that, the user could create own meta tags to mark the files in any way imaginable.
Locating files would be done through search - all-in-one search bar that searches for all tags (see above commend on locating programs), or an "Advanced search" that allows the user to select only desired tags to search by.
Let's take it a step further: Replace the word "file" with the word "object". If searching is usable enough, we do not need a "flat file namespace", but rather an "object store". We can use advanced database techniques that are being employed (successfully) all around the world to create and index the contents of a disk.
"But how can I copy all the files related to my project to another machine?"
Either you search broadly and click through the list selecting only what you need, or you were smart and used a tag with the project's name on all the objects belonging to it. The IDE could help us here by appending the tag automatically. Then simply exclude the objects with tags "temporary" and "generated" and you're set.
"How to delete all the files with user settings?"
Search for tag with program name, then exclude all objects tagged "settings".
"Won't there be entirely too many tags on any given file after a while?"
Perhaps, but if the OS sets nice, usable policies and programs stick to them it should be fine. Plus, with advances in hardware and databases this will not take a lot of space or slow things down significantly. I for one am willing to risk it.
More on this in the future (perhaps).
No comments:
Post a Comment