Hi everybody,
I was thinking about the project, and how it could be a good thing to
have a well-known, public roadmap, and a clear vision of what we want
to achieve, and how. The Wiki
(http://www.dromasoftware.com/etoile/mediawiki/) is interesting, but
I'd like to synthetise our plan.
I'll use the name "étoilé" for the moment to describe the project, so
feel free to s/Étoilé/$YourOwnPreferredName. Although it's My Own Plan
for the moment, I hope you'll find it interesting enough to discuss,
complete and hopefully adopt.
Warning: it's long.
So, What's The Plan With Étoilé ?
Étoilé wants to be a desktop. But, an innovative desktop -- there's no
point of redoing KDE and GNOME -- we are not enough people at the
moment to be able to catch up, and KDE/GNOME already works "well
enough" for most of the users. We're not going to attract anybody if
we are not different (as in, much better). While it could be fun to
redo a good "classic" desktop using GNUstep, personally I think it's a
bit futile. So, we ought to aim higher, and don't be afraid of
"breaking rules".
What would be a good desktop then ?
A) components, cooperation and sharing
1) existing mechanisms
I think that one of the main point of a good desktop would be good
cooperation between the applications/components. It's better to have
applications/components doing only one thing, but doing it well,
cooperating with other applications, than to have huge, bloated
applications that do everything in an average way.
How can we do that ? well, there's different possibilites. Using
GNUstep already gives us a lot of mechanisms for cooperation:
pasteboard, services, filters..
NeXTSTEP showed how the pasteboard could be the central communication
bus for exchanging data between applications. We should build on top
of that and encourage theses mechanisms.
2) proposed additional mechanisms
On top of the current mechanisms, we probably want to add things like
"roles" (where you could identify roles in applications/components and
call / use roles instead of application -- hence providing a good
abstraction over which actual application / component will do the
job), "programmable services" (ie some kind of registry for services
callable using distributed object), a more powerful filter system, and
of course NSDataLink/Linkback for embedded documents edition.
3) scriptability : one virtual object environment
Another aspect is of course easy scriptability of the environment --
ideally we want to provides the illusion of cooperating objects over
applications. Exactly what StepTalk does : Étoilé applications should
have a good StepTalk support.
4) sharing
Another important part in a good desktop would be an emphasis on Once
And Only Once : databases must be shared across applications (things
like the adressbook, the bookmarks...). The user should not have to
type/enter informations more than once, as a general rule.
This idea is also true for sharing components among programs as much
as possible. Providing Gorm palettes for components would be nice !
B) Documents
1) Throw out the application centric point of view when it's applicable
We should try to provides an interaction model more directed toward
documents than toward applications. What I mean is, whenever it's
applicable, we should put the document first and the applications
second : the user don't want to "start OpenOffice" but he wants to
create a letter. For that, we need to provides an easy way (interface)
for creating documents; for example, applications creating documents
register to the system and that information can be used to present the
user a choice of all the available documents (s)he can create.
On the other hand, not every applications deal with documents (for
example, an FTP client), but overall documents are really important.
2) Searching documents
If the documents are central to the user, something needs to be done
to help the user order and search its documents. LuceneKit will
probably be very helpful here. Perhaps we should just impose a
metadata-enabled filesystem such as ReiserFS ? remember, we shouldn't
care about compatibility..
Other User Interfaces ideas (Beagle?) for enabling search by creation
date ("I did that one week ago" are also worthwile. I think we could
modify NSDocument to provides some of theses things.
3) Versioning
In addition to search/order documents, one important and nearly always
forgotten aspect is the document versioning problem. We should
provides tools/frameworks for that ! it's a shame that the user either
does the versioning "by hand" (using multiple copies) or using a
versioning system not integrated to its tool ...
C) Network / Communication
In thoses days of Internet, we should have a core communication
framework. "Persons" should be first-order object in the UI -- you
should be able to drag'n drop something on your friend's icon to send
it to him. Different communications mechanisms exists : we can use
distributed objects, applications (mail, ftp..), jabber, soap or
xmlrpc, etc.
Having a generic communication/transfert framework would be
interesting -- an application could just do "I want to send that to
this" and the framework will relay the demand on the available
applications (in case of a person, we could check its adressbook
entry, and depending on the entries, propose to send by mail, by
jabber, etc).
C) The Desktop
1) Consistency
Obviously, applications should follow a strict set of HIG rules -- we
want to emphasis consistency and good UI.
2) The user interface aspect
We will use Nesedah (or a Nesedah variant) as a default theme.
3) filemanager ?
We'll provides a file manager (the one quentin is working on). But
using the "roles" ideas, we should be able to work transparently with
other file manager/desktops (as long as they answer to the "role
protocole").
4) Documentation
Documentation is really important -- Étoilé applications should have
good online help. I expect to be able to work on HelpViewer in a
couple of weeks and commit it to the cvs.
5) Applications/components installation
Obviously, we want the installation process as painless as possible.
Installer.app will help a lot here.
D) Roadmap ?
Thankfullly, a lot of what I have explained is implementable now using
GNUstep, it's more "rules" to abid to than whole new developments.
Though, there's of course new developments needed, apart applications.
I'm still unsure about the roadmap, which is why I'm requesting inputs
here :-)
I think the "roles" idea / service registry is central enough to be
implemented soon, and will let us experiment a very flexible desktop.
E) Development tools
Étoilé's goal is to provides a desktop. But we should provides
development tools if they are helpful. For example, we have
UnitKit/UnitTests on the cvs, and we should use them as much as
possible (ie, it's strongly encouraged !). A framework implementing
High-order methods would also be a nice thing to have "by default".
etc.
------
Ok, it's finished ;-)
I wasn't very precise on some points and on the roadmap, but I tried
to put together a good overview of what I'd like in a desktop..
Critics encouraged !
Thanks,
--
Nicolas Roard
