This is not a task orientated desktop, it doesn’t even consider what a task is, it considers what workspaces are in a vain attempt to get people to use more than one workspace. I’ve been in the process of designing a task orientated workflow, partly in my head, and partly on paper since GUADEC. Since the immortal words of Don Scorgie were spoken, “a f*cking project is a top level object” – he exclaimed with exasperation as he smoked…
Lets ask some questions first, clarifying why Scorgie was so adamant about this…
What do people do with their computers?
- They write letters, reports, and various other word processed documents
- They create spreadsheets and graphs etc…
- They draw pictures
- and many more things, but there is a pattern… people use applications to produce things.
Why do people do these things?
- Because they’ve been asked to
- Because they need to produce something to show someone
- Because they need something tangible which documents and guides something they are trying to achieve.
- Because their artistic nature demands it of them
Essentially, people are performing tasks, and a task is not what an application is, its not which applications are open, its not what is sitting on your workspace its something far more abstract than that.
So what is a task?
A task is something that you’re doing, in an office environment you’re generally asked to do various things by your line manager, or you have a general set of responsibilities which involves you producing documents, spreadsheets, reports etc…
So, what the hell was Scorgie on about? Projects are toplevel objects? Well, I think what he means, and he can correct me if I’m wrong… A project is a collection of tasks, or more specifically and less stringently a task which has many tasks that depend on it, projects are the most important things we’re working on and are the elements which everything, or almost everything descends from.
Everything we do productively at our computer is a task, even if we think of it in terms of the code we write as developers, what we have is a top level task, a project, for instance to take for example nautilus, that project is built from a series of tasks, these are feature requests, bug reports etc… Each task can have files associated with it, maybe in the case of nautilus, which files need to be edited for a bug to be fixed, and each task can have people associated with it, as in who is involved in completing the task, and many other roles people can perform in relation to a task.
Essentially we should be organising our time over a project managed approach to our work flow, I’m not saying that we employ a project management UI, I’m just saying that tasks, and task dependency and relationships need to be considered in how we interface with the desktop.
The BIG problem with this is how can we convince a user into using a task orientated workflow, how can we ensure that they’ll follow the model we’re trying to get them to use?
This is where we need to think carefully, Federico is making moves in this direction with the journal, obviously we do need a way to track what we’ve been doing and when. However we also need a way to track why we’re doing things and gather more metadata about what we’re doing, while building relationships between the relevant bits of data.
For instance, and I keep using this example, now with characters, Sally receives an email which states;
“Hi sally,
Can you take a look at this file and update it with the current figures by tomorrow at 4pm
Thanks
Jessica
File attached: tps-reports.odt”
Now obviously we know what the instruction is, we could right click on it and create a task, set the due date and time from what’s contained in it and then make sure we follow our task list…
How many people do that?
What’s so difficult here? Its not that its so difficult, its that the user doesn’t want to spend the effort doing this, as its more time wasted… I think eventually you come up with a tangent curve which shows the amount of time doing stuff vs. the amount of time organising your time into doing stuff… We can fix it but currently the software doesn’t pay attention to the user, isn’t aware of the user, and isn’t aware of what they are doing. We can make the software aware, we can gather so much metadata from this simple email, firstly, we pull out the file and dump it into a semantic revision controlled filesystem 
, next we know who is related to the file because we know who it came from, we also know when the file must be updated by, we can even extrapolate the section of a sentence which describes what needs doing to the file. We can even gather a reasonably relevant name for the task from the file, and with the power of a semantic file system we can build relationships relevant to the project the task is related to.
The computer can easily know much more about what we’re doing, we can create new ways of seeing this and managing it without becoming obstructive. One of the big problems with the current GNOME shell is the word applications. People don’t really know or care what an application is, moreover its a foreign word as Windows calls them programs… Here is the quandary.
Should we copy Microsoft and rename it to programs for cross platform consistency, or change the paradigm? I think its time we changed the paradigm…
I think we need to consider intelligently gathering metadata from our behaviour and communications as well as from files, we need to join this all together and do away with the term ‘applications’, we need to change the way we interact with files.
Templates are a good start to removing the applications concept, we have templates which can only be used to create a new document from, these templates are how we are productive. For instance if we want a new letter, we can open a template and our contact details are included as well as the contact details of the person we want to send the letter to, it builds a template for us with the relevant data in it so we can just start typing and then print it.
A simple improvement to the context menus in nautilus.
Files are only ever really viewed or edited, so why not build our viewer so it can handle any kind of file, allow us to flick through files page for page, zoom in and out and view them in any way that’s relevant to the file type, and set the better editors as the default for editing each file type, distributions could employ an overlay of configuration there easily. Eventually the concept of applications for editing will become null and void because when we open a file we open it to edit, when we view a file we’re viewing it…
It’s important that we dissolve away the concepts we’ve found over the years don’t work or impede the use of a computer, Xerox was looking for the paperless office in the 70s and stumbled across a paradigm similar to this. It was simpler, and there was less variation and file types to deal with, but the idea was there, a networked method of communicating produced items with objects representing things in the real world.
For us to get there we need to invent some cool stuff, semantics is one part, organising the data by what it is rather than where it is, especially when the user has a tendency to loose things in the jungle of file systems. Journals and revision control are another part of it, remembering what we’ve been doing and when, but also templates and schema’s are part of it too, hiding the notion of an application behind the tasks you want to achieve and the things you want to get done.
So my action is not an application, my action is starting a new task or continuing with an old one. Workspaces can easily grow from the natural separations seen between tasks, rather than artificially created and badly managed by users.
I think we need to be more productive and shape the future rather than just say no to it. I think that maybe some of the new UI is good, but what we present within the container is also important to the user and we need to put more effort into that. There’s nothing to say that the scene graph and compositing/window management built into the desktop shell is a bad idea, in fact this is the most inspiring part of what came out of the shell hackfest. I think it comes down to more about how we do things than what it looks like and the underlying technology. We need to be smart about metadata and smart about the user’s behaviour. Its definitely time for artificial intelligence in the desktop that understands what we’re doing and why we’re doing it and who we’re doing it with.
Now there are people who may disagree, for instance Theodore Kaczynski, but that doesn’t mean that AI shouldn’t be there to help us in doing what we do, it could dramatically improve our human computer interaction without being as lame as voice recognition and animated paperclips.
If you’re going to deal with metadata, please look into KDE’s Nepomuk. For some things, it’s really not worth having several separate implementations just to satisfy NIH. If I associate some data with this file, I don’t want to set it again in Nautilus just because the devs were stubborn.
This sounds fascinating.
I wonder how you will eliminate applications entirely? Could it be via plugins for the editor so gedit knows about matlab actions when you are editing a .m file?
I also agree that today applications are too much like silos, we need the operating system to know much more about the files. This requires massive amount of work but I think it will pay of in the end.
People browse the web, chat, download stuff, take pictures with their cameras, watch videos, listen to music, etc. You are only seeing the “work” part of the equation. The “fun” part is left alone.
Hey, this is a lot like a little project I’ve been secretly poking at. (At this point it’s in the “imagining” stages, albeit at the more believable point of that, which is why it’s still secret
)
Your mockup of the Nautilus context menu is funny, because it is the same colour and opacity as mine
So here’s part of what I came up with, to get the thoughts flowing:
http://img79.imageshack.us/my.php?image=calciumpopupmockupws3.png
(And yes, if you look closely you’ll see it’s called Calcium. Basically a library with magical integrated building blocks for a shell. I like to think that the shell is made up of every application on your computer, not just a single application that is there when you start it up. That is how things are now, even, except right now such a thing was not planned for so it’s all rather disjointed).
With mine, the thought is a bit different. One thing that inspired me was how totally bizarre and unintuitive an action double clicking is. With my idea, that popup would expand over an icon when it is selected (clicked once – yes, this kills single click to open /and/ double click to open, rendering the debate redundant). Clicking the preview icon a second time would open the last program used to edit the file, to keep /those people/ happy, but the magic would occur with the extra Actions at the bottom. Arguably little difference between it and the Open With menu, except that Open With generally lists redundant things like various text editors. Actions would be determined a bit more intelligently based on document metadata like dimensions, folder contents and regexes, to be a bit more useful and a bit more accurate at guessing what the user wants.
This would encourage a different, more natural direction where the user can have a certain file be the centerpiece of his project, then performs various actions on that one file.
The big problem with the shell right now is that it works in two directions, largely thanks to cruft left over from certain popular operating systems which did not multi-task. (Thanks, Steve! All three of you!). You can open an editing tool, then open the file you want to edit through that; or you can open the file with the editing tool; or if you’re crazy like me, you can do it half and half via drag and drop. To make matters worse, every direction uses a different file manager with a different perspective on what the user wants to view. Let’s say the user normally uses a photo manager like F-Spot. If he wants to “edit the photo”, he will find a lot of pain hunting for it with the GTK file manager that GIMP pops up because it is not how he had organized them in F-Spot. Further, if he edits F-Spot’s image by opening it via GIMP directly, that will lose the Original version. In a sense, we are forcing users to think of thier Photos, their Music and their Essays as generic “files with x kilobytes of data”. That is the opposite of what these user interfaces are meant to achieve.
What if a web form asks the user to upload a picture of himself? Well, he has a webcam, so he just has to snap a picture for the site. Right now:
-Open Cheese (know what Cheese does)
-Take a picture, then save it to Desktop (I’m going easy; normally the user would just take the picture and expect it to be magically found)
-Return to the web site, and click to browse for a file…
-Find the file saved from Cheese and upload.
It’s a major mess in too many ways to describe. That there requires we think in both directions!
What if the user could do it in a single motion, instead?
-Click to Browse on the web site (because of course the interwebs target our broken competition in Redmond)
-File dialog realizes that the program wants an image file! It locates programs that will output image/png or image/jpeg files via a magical interface. Presents a generic file browser (Nautilus), F-Spot, gthumb, GIMP, MeMaker and Cheese with short descriptions of what they each do.
-The user chooses Cheese, which launches in a slightly special in-line mode. User snaps a photo, accepts it and the photo gets returned to the web page.
It’s all about the shell.
So kudos to you guys for dreaming up solutions. Hopefully we’ll all agree on something great
Hi Karl, please read http://cgwalters.livejournal.com/5659.html and you will see how your “people use applications to produce things” is wrong. The difference is not large, but it does exist, and should affect the way people access and use functionality.
Your post is otherwise very good. People don’t want to use computers. People don’t want to use applications. They have real tasks to accomplish. They can be having fun, writing the darned memo about the meeting or whatever, but there’s always a task.
I think you’re totally missing some things. Like for instance hiding unavailable menu-items: you want the menu to be the same always, so you can learn where to click, or how many times to press navigational keys, so no removing of items. You also mention the possibility of tabs in the menu FFS, tabs in a menu… Have you totally lost your mind? I guess that was just a late guadec joke, because by know everyone should know tabs do not belong in menus. You also suggest introducing clicking to rename a file. Although I might agree with you that there could be an action associated with clicking a file when it’s already selected, I totally disagree that action should be renaming the file. I’ve used windows too, occasionally I install windows these days (as sysadmin) and occasionally I run a few apps on my own windows install, but I’m glad I don’t have to do any serious business on it because of the retardedness of things like clicking a selected file to edit it’s name. It happens so often that you accidentally click a file a second time or click it when changing focus to that window again, so it’s only going to be an annoyance. Besides that I don’t like to change names that way, I also think filenames are becoming less and less important. Photos have EXIF attributes, all files can have tags (depending on file browser) so the filename isn’t really that important.
I think you might have some good ideas with the whole ‘people do tasks’ stuff, but I think it’s way over your head… A good test would probably be to write everything you mentioned, get drunk, and test it. If you succeed, then maybe it could be something for other people as well…
This reminds me of the “Zoom Interface” where all you have got is a large ‘desktop’. Files and application windows like webpages flow around in piles, where you’ve put them.
This is studied to be very intuitive for the human brain, but noone actually got it just right, probably because all the applications had to be “built in”.
well written. This is exactly the type of operating system I would like to use.
my only gripe would be that the default should be to view a file, not to edit it. Maybe its that I’m in a profession that requires a lot of reading and reviewing, but I view files about 90% of the time and edit them only 10%. From that perspective as well as your nautilus menu, I think viewing programs should have a button or Menu option to “edit file” which would then launch your preferred editor for that file type. (a plus would be visual continuity. not closing document and opening it again in new program, but having editing program appear around the opened document. But that can come later;) )
BTW, this stuff is kinda like what the OLPC people are/were doing with the Sugar interface.
Interesting that you mention Xerox. You know what the Xerox Alto didn’t have? Applications. There was one and only one document editor. It handled plain text, richly-formatted text, images, e-mail,…everything. You didn’t have to worry about what programme to use because opening a document always used the same extensive programme. And you didn’t haven to worry about what kind of file to use, because there was one and only one kind of file format and it handled everything. If you wanted to send an e-mail, you wrote up a standard document and copied it to your outbox. That simple. 100% document-centric. We already have a document format that is extensible enough that it can handle everything: HTML. And we already have a programme that can theoretically handle any kind of use for that document format: the web browser.
Instead of trying to disguise applications by calling them “tasksâ€, let’s try to get rid of them altogether. And let’s make GNOME at least as document-centric and application-agnostic as Xerox’s systems back in the 70s!
Great mockup
That seems very reasonable.
I must say that your list of “What do people do with their computers?” isn’t exactly applicable to most people I know who use computers. I mean, it matches some office workers, but most people I know do this with their computers:
* surf the web, reading news and fun stuff
* read/send email to friends
* use IM clients to chat with friends
* play games
* use social sites like facebook
* listen to music
* watch movies
Its kind of weird to call any of these “tasks”, and they certainly aren’t a part of some “project”. “activities” does seem to categorize them better though.
So, imho tasks are not really a general enough concept to describe a lot of things users do with computers.
Interesting! The stuff about AI is a bit far out. Semantic revision controlled filesystems sounds useful. I suppose this is a versioned file system + metadata?
Reducing the importance of Programs/Applications is urgently needed, if only because so many have silly names. Some apps (or should I say “tasks”?) like Cheese, Monkey Bubble, emacs, still need to be in a menu. But I would prefer most apps to be launched from a template, like you say.
I don’t think it’s necessary to the computer to organize tasks for the user. The task is only in the user’s mind. Just give him “Documents” as first class objects, easy to store, easy to find. Make it easy to load up and flip between groups of documents.
Interesting about the single viewer for all documents. Something like gthumb, except not just for photos? Sounds like we need to bring back Bonobo embedding.
Maybe it’s enough for all editors to have a read-only mode and make them all look and act in a similar way.
It’s great how many people are writing about such topics on p.g.o. They have great resonance with me when e.g. I have just helped gf who was trying to use GTK file selector as her file manager. Strangely she manages OK on Windows. Last night she asked what extension to rename a MP3 to so it can be burnt to a CD as audio. “Change the paradigm” — I Agree!
@Sam, Rob Taylor is already on that, and so is Sebastian Faubel, we’re not re-inventing the Monkey!
@Sebastián BenÃtez, I understand that people do those things as well, and that they’re not exactly part of a task, however there are things people are doing that are task related, as I said, we want to use some underlying AI to gather *special* metadata, Dashboard was doing something like this, back in the day however I have a different goal in mind. The task orientation isn’t imposed its just there to help you index things. With this kind of symbiosis of technologies for indexing, journaling and revision control etc… we’re just adding to the available classification.
@rawsausage, what you’re missing is the inherent unboxedness of the whole thing. For instance objects are not constrained to task boundaries, tasks are tagged to objects, a relationship is created between them and its not an exclusive relationship, not that I’ve created a container and bunged it in there.
@Michael Croes, flame much? I put a lot of the ideas out there as things which I already understand will need some user testing, like real world user testing. But I seriously think the context menu is in need of a 21st century update.
@Mike, the default opening choice could be definable I suppose, it should also be aware of files too, for instance I would by default just want to play a movie file, so instead of seeing view/edit I see one button for play. However when I open a PDF I don’t want to edit it…
I see your point, well made
@foo, hmm, imaginative
OLPC was something I’d kinda been watching as their UI grew, its a fantastic project and amazing people work there. The UI has a lot of similarities here, but there are actually lots of people who’ve been kinda thinking in this direction. Even *them* … http://en.wikipedia.org/wiki/Winfs
@david, document centric is dead, semantic file systems improve this situation somewhat, however at the end of the day its more about what I want to do with my document that counts.
@Alexander Larsson, that stuff you mention, that’s already aced, applications like those are quite easy metaphors to disguise and obviously, not everything has to fit into a box of tasks. Although, browsing the web, instant message buddy, send email are tasks… They are tasks which exist only for the duration at which they are undertaken. We don’t even have to use the word task if you like, but at the end of the day the “doing something” metaphor is obvious.
@rvl, the AI is essentially a passive AI that just noses through your stuff and grows knowledge about you and your work on the computer. You’ve also made a similar mistake to a few others in thinking that a task is a container rather than a property, its wayyy more flexible when its just another property or relationship for the object.
I think one important thing for a desktop is the difference between an available application and a running application. With the current system, you can have Pidgin, for example, in the application menu, on the upper launcher, in the window list and in the tray.
Two of these are shown all the time, and will lauch another instance, two are related to the currently running version but the other two will still be available and clickable.
In my ideal desktop, I’d like a notification area shared by all applications with a simple icon to show new activity which when clicked shows something like:
New Notifications
[PIDGIN ICON] Josh has sent you a message: Hey buddy I was…
[THUNDERBIRD ICON] You have a new email from ‘jenny@collabora….’
————————–
Recent Notifications
[EPIPHANY ICON] File ‘fedora8.iso’ has finished downloading
The idea of the menu would need to be revised, there should be one icon for an application. Perhaps the Mac dock is a good inspiration but perhaps the current Gnome model of an Upper launcher icon could be there which could then ‘drip’ down to a lower bar showing it is now running or some other type of visualisation.
I think the desktop should have no user icons but Home, Devices and Trash should be present on all of them.
An area for recent documents/Timelined docuements or actions should be encorporated. These are things that would make a system usable for me without the need to redefine menus or the paradigm too much, just a natural evolution of making the user the focus, not the applications.
I really want to see this shift happen and hope Gnome will seriously reconsider not making 3.0 a break from 2.X. Task, people, and document centered desktops need to happen.
My ideas?
http://blog.ibeentoubuntu.com/2008/10/concept-desktop-basic-sketch.html
There’s one thing that makes me thing it’s gonna be hard.
People writing applications won’t want their “babies” to be hidden in activities. Think of a professional ISV. They want their application to be some kind of a showcase for their company.
If everything is activity-based instead of application-based, commercial ISV might not bite at it. If they don’t, they will remain on the other system that is much friendlier to them. With the current monopoly it has, people will remain used to the application-based metaphor (and their favorite apps) and won’t want to switch to our much better activty-base metaphor.
Worse: I suppose Gnome will have one application for each task, each one being hidden by the more global interface of “viewing or editing files”. This means existing apps by the community won’t fit into this new model. People will lose the applications they like. This might feel a lot like some dictator is imposing us how to use our computers.
I’m not criticizing the activity-based metaphor (I’m only discovering it with Sugar for a very little time), I’m just saying it could be a very long and difficult way (but if it’s for the better, it could be worth it
.
bochecha, I think the point is not purely to kill off the application metaphor, but to reduce it to pure productivity applications. Imagine an ISV market which has a rich platform for application developers to integrate into, a platform which isn’t purely about the applications but how the applications work together into the getting things done mentality.
I think ISV’s would be happy with that, in the same way microsoft saw they’d be happy with the now defunct winfs
[...] http://www.qdh.org.uk/wordpress/?p=244 [...]