"This essay is a manifesto about software for collaboration -- why the world's future depends on it, why the current crop of tools isn't good enough, and what programmers can and must do about it.
It is only proper that such a manifesto begin with the story of Doug Engelbart. In the 1960s, Engelbart and his laboratory at the Stanford Research Institute (SRI) invented the fundamental building blocks found in all of today's collaborative tools -- everything from the data structures (hypertext) and user interfaces (windowing systems), to applications (groupware) and physical interfaces (the mouse).
Engelbart's work was driven by some deceptively simple observations, which he described in his 1962 paper, "Augmenting Human Intellect: A Conceptual Framework." His thesis was this: Society's problems are scaling at unprecedented rates, so solutions need to scale also. Our very survival depends on our ability to work together more effectively, to get collectively smarter. Computers -- when used properly -- can help us do this.
Today, we celebrate Engelbart's accomplishments, but we forget his motivation.
Computers should help us become smarter and work together better, and in many ways, they have.
But instead of progressing, tool builders these days are moving in circles, treading water rather than swimming forward.
Good Enough Is Not Enough
One reason for this stagnation is that we seem to think we've reached the limits of what software can do for us and what we can do with software.
Nothing could be further from the truth.
Our software tools -- particularly in the collaboration space -- are nowhere close to fulfilling their potential.
Consider a basic collaborative task: document-sharing. A number of applications (both commercial and open source) claim to solve the document-sharing problem, and yet, the predominant method for sharing files is to email them back and forth. This is the computational equivalent of sneakernet. If the tools that purport to solve this problem are good, why aren't we using them?
We see similar problems in other basic areas. I can walk into any meeting anywhere in the world with a piece of paper in hand, and I can be sure that people will be able to read it, mark it up, pass it around, and file it away. I can't say the same for electronic documents.
I can't annotate a Web page or use the same filing system for both my email and my Word documents, at least not in a way that is guaranteed to be interoperable with applications on my own machine and on others. Why not?
Solutions to these individual problems exist.
Unfortunately, most of them are not very compelling, usually because they are not designed with people's needs in mind. On the other hand, some of them are very good. Unfortunately, being good is not enough.
The reality is that our needs are broad and varied. We use a number of different tools to do our work, and we always will. In order to make a real impact in the collaborative space, tools must not only be good, they must be interoperable.
Improving collaborative tools, then, boils down to this:
We must be people-centric when designing and building applications, and we must work with other developers to make our tools more interoperable.
People Come First
The natural starting place for building people-centric applications is the user interface. The opportunities to improve here are endless, and the increasing number of publications in this area show that people are paying greater attention.
Open source software offers an excellent and underutilized avenue for disseminating innovations in user interface.
Researchers should be writing plugins for widely-used open source applications, such as the Mozilla Web browser, instead of developing prototypes from scratch.
Open source developers should be scouring academic publications for ideas, rather than simply duplicating the user interfaces in commercial products.
Being people-centric isn't just about user interface, however. It's about attitude -- how we think about our applications in general. The wrong attitude can steer people away from some very useful technology.
A Shared Conceptual Framework
The second step towards improving our collaborative tools is to make them more interoperable.
Some opportunities for standardization are obvious -- instant messaging protocols, for example -- and, in many of these cases, these efforts are already underway. There are, however, less obvious but potentially more significant opportunities for standardization. In order to identify these, we need to have a shared conceptual framework for thinking about collaborative tools.
A shared conceptual framework for collaborative software would provide a common vocabulary for thinking about and discussing these tools, and would also reveal opportunities for standardization.
In order to create this framework, we need to identify the commonalities between different collaborative applications.
One area of focus that would have a particularly significant impact would be to standardize the way we view, express, and manipulate structured data, especially documents. In other words, do for documents what relational algebra and SQL did for databases.
All collaborative tools generate data, usually in the form of a structured document. At the most basic level, all tools allow us to do the same things with this data -- create it, view it, and sometimes edit it. Today, it's clear that other basic tasks would be desirable in all of our applications as well.
Roadmap for the Future
All of the conceptual and technical ideas proposed in this essay share one thing in common:
They won't make a difference unless tool developers work on them together.
Creating a shared conceptual framework is a truly collaborative problem.
It will not be solved by a single person in an ivory tower and forced upon the rest of the community.
It will require constructive, passionate dialog, open minds, and much experimentation. It will require respect for other people's work and ideas.
Most importantly, it will require a shared desire to make the world a better place by improving the way we work together.
With this in mind, these are the steps for improving collaborative tools:
Be people-centric.
This applies both to how we design our tools, and how we market them.
Be willing to collaborate.
We all belong to a community of like-minded tool developers, whether or not we are aware of it. Working together will both strengthen this community and improve our tools.
Create a shared language.
Our tools share more similarities than we may think. Conversing with our fellow tool builders will help reveal those similarities; creating a shared language will make those similarities apparent to all. As a shared language evolves, a shared conceptual framework for collaborative tools will emerge, revealing opportunities for improving the interoperability of our tools.
Keep improving.
Improvement is an ongoing process. Introducing new efficiencies will change the way we collaborate, which in turn will create new opportunities to improve our tools.
Finally, never forget Doug Engelbart's fundamental tenet:
Computers should help us become smarter and work together better.
Remembering this will keep us on the right track."
