Appendix G
A Desktop within a Desktop?
One cannot help making the observation that the applications we're
developing are desktop-like in nature. We end up having a desktop
running within a operating system's desktop. The features of our applications'
desktops are in many ways a replication of the features already built
into our operating systems. The main difference being that instead
of managing files and folders, we're in a sense extending the desktop
to allow for the management of business objects, in any combination
we choose. When we wrote our contact manager, that combination happens
to consist of persons and businesses, for example.
G.1 Dreaming of a Better Virtual World
The state of operating systems today looks all charming and wonderful.
Take for example the new MacOS reborn in v10.0. Beautiful graphics,
colors, lots of applications we can run. On the surface, it all looks
and feels like a virtual garden of eden.
I see a much colder, harsher landscape. I see a landscape of islands
of processes that communicate with one another hardly ever. If they
do, it's via messages in a bottle. One of the few ways for such applications
to talk to one another is via the clipboard. You copy (or drag) some
text or maybe an image from one application and paste it (or drop
it) onto another. That's essentially the extent to which applications
can communicate in an ad-hoc basis.
Let's go a little further though. Let's think about the code required
to implement an email application, a web browser, a word processor,
our finance application, etc.. Each application must fend for itself:
each one has to build its own search features, its own mechanism for
persisting information, its own user interface, its own mechanism
for calendaring, for validating information, etc..
This is not entirely true; the operating system does provide certain
services that any application can avail itself to: reading a file,
writing a record to a database perhaps, opening a socket, creating
a button, a text field. Terrific. It's a start.
Again what we see is that the notion of orthogonal services that can
be provided to all the applications that run in an operating system
is missing. If the ideas embodied in JMatter were to be applied to
an operating system, then we could create a virtual world where our
software applications would suddenly and dramatically shrink in size.
The reason would be simple: all you'd have to do to build your application
is define your model objects. Half of them would already be defined
in other applications and you wouldn't be writing them from scratch:
you'd be composing applications.
Contributors to such an operating system might add new and interesting
behaviors on existing objects. Maybe the ability for an email message
object to receive an image object, maybe the ability to submit your
financial information electronically to your accountant. You'd be
able to file email messages in folders that you place on your desktop.
The notion of multiple separate applications would vanish. They'd
all run under a single application, managed by the operating system.
When you're performing a search, you'll be searching your entire virtual
world in the same way, regardless of whether you're looking for a
piece of text in a file or an email message, or maybe looking for
a financial transaction in a specific electronic account.
We wouldn't need such large hard drives, and for many tasks, would
not require such a fast microprocessor. Each application wouldn't
request of the operating system a chunk of 50 megabytes to run in;
your memory footprint would drop.
When you perform a software update, you'll be inheriting new orthogonal
services: new capabilities that all of your objects would inherit,
not just a single application.
This is my vision for operating systems. It turns out these ideas
are indeed very old ones. What I'm describing, to a certain extent,
is Smalltalk.
Indeed the ideas behind JMatter were inspired by the NakedObjects
framework, which in turn was inspired by Smalltalk.
G.2 Collapsing the desktops
So, my hope is that some day a single desktop will exist and the ideas
in JMatter will be integrated into our operating systems. Until then,
enjoy smashing your competition to bits with JMatter.