Re: Project Soylent

[Kalle Vahlman <kalle vahlman gmail com>]

On 5/2/05, Travis Reitter <treitter-dev netdrain com> wrote:
> Over the last few months (without much concerted effort), I've put some
> thought into what seems to be a cleaner way to use the Gnome desktop to
> communicate with other people.

Incidentally, I have been pondering the same thing.

I started with an idea to translate the IRC protocol in to dbus
interface, to get real frontend/backend separation and allow all kinds
of cool stuff in terms of monitoring IRC-traffic and so on. Thus came
Irksu and the DBus-IRC spec [1].

After I got it somewhat working, I started to think (not entirely
uninspirated by the naimng-stuff the Naim people are working on) that
it would be cool to have other protocols too, so one could initiate
all kinds of communications through dbus transparently and not really
caring *what* app handles the request. With this, initiating
communications could be aggregated to say, one or two applets.

With the introduction of decently working GObject bindings to DBus, I
devised a scheme where a series of backends would provide protocol
objects that could handle the message transporting through common
interfaces, where applicable (i.e. sending message to a user can look
the same from the senders point of view, it really does not matter if
it is an ICQ message or an IRC query that actually happens). This is
pretty close what the naimng is about.

The users could be objects too, each having their distinctive
properties. The information for a specific user would be aggregated
from different sources to that one user object. The users would have
their own dbus interfaces for querying their information (email, ICQ#,
IRC nick, real name etc.) so the user objects could be used in a
variety of apps (a desktop-wide contact system actually :).

>From what I understand, Galgo already provides much of the user-side.

I'm working on (as much as I have time after recent move and starting
a job and of course my family) implementing the DBus-IRC stuff as
GObjects, so that could be a basis for the protocol object part. Given
the oo nature of things, new protocols will be easy-ish after the
ground work is done.

What is needed is a good spec of the interfaces required to make
thinks work, collaboration between different projects to get all the
objects glued to the approperiate apps (i.e. protocols to irc-clients,
users to galago/some other service) and working out some
implementation details (like where the objects actually live, a
separate daemon or what?).

Oh, and everything but the frontends should of course be independent
of the desktop environment, so perhaps there is a better list than
this to discuss it (xdg?).

[1] http://iki.fi/zuh/kalle/projects.html

-- 
Kalle Vahlman, zuh iki fi