[DotGNU]Butler webpage

[Peter Minten]

Hi folks,

I prepared a webpage for the Butler that explains a little what it does. It's
attached. Gopal, could you put this up on the website?

Greetings,

Peter

DotGNU Butler

Introduction

The DotGNU Butler is the most important part of DotGNU that runs on the client. It's goal is very simply put to manage just about all DotGNU communication to the client. More specifically it:

• Contacts webservices at the users request and logs in without the user having to take any extra action (besides maybe entering a password).
• Sends commands from the webservice on to the webservice frontend that runs on the client.

The webservice frontend

A webservice communicates with the user through a frontend that runs on the client (the computer of the user). This frontend is a program that runs in a separate process. At the moment frontends have to be written by the webservice author, but in the future the frontend will be completely controllable from the webservice server.

In the future setup a webservice programmer will create the user interface just like in a normal application (almost, a little extra work has to be done but we're trying to limit that as much as possible), on the client side a special component named Translator will construct the user interface and connect it to the webservice.

DotGNU + FOX = webservices with a GUI

It's usually rather tricky to work with a user interface toolkit (like GTK) over the internet, because you must connect all the toolkit functions with functions that can be called from the internet. There is one imporant exception to that rule however: the FOX GUI toolkit. FOX uses a message passing mechanism that is implemented in a class hiearchy and uses numbers instead of pointers.

The FOX message passing mechanism can work over the internet using only one function, which is the same for all FOX classes. Another advantage of FOX is that about all stuff which is normally done with functions can be done with messages (getting values, setting values, etc), a FOX object can (usually) be completely controlled with messages.

DotGNU uses FOX as it's primary GUI toolkit for webservices. We also use the message passing mechanism of FOX extensively for all communication between the webservice and the frontend.

Support for other user interfaces

One of the great advantages of FOX message passing is that DotGNU doesn't need to know the type, interface or implementation of the objects involved as long as they inherit from FXObject (the root of the FOX class hiearchy). This information is only of use to the webservice programmer.

As a consequence DotGNU will automatically support any library that implements the FOX message passing mechanism. This is particularly useful because the FOX classes don't cover the whole range of user interfaces. I expect that in the future we will see a FOX wrapper for curses, for example. This way the DotGNU user interface can be extended without us having to code the whole lot (which would be the case if the extension was DotGNU specific and hard to code).

How it works

The whole system of message passing over the internet works like this:

• On the client the user clicks a button.
• The button sends a message to the DotGNU Translator.
• The Translator serializes the message and sends it through a pipe to the Butler.
• The Butler deserializes the message and makes a XML-RPC request out of it which it sends through a Jabber connection to the server.
• On the server the DotGNU Execution Enviroment implementation (VRS or SEE) receives the message from it's Jabber account and sends it to a Translator.
• The Translator sends the message to the handling code.
• The handling code sends a message back, using about the same steps as before.

The future in phases

The creation of the Butler and the DotGNU frontend architecture is a phased process. Here's a rough plan, we are currently at phase 0:

• Phase 0: It's a kludge, it's buggy, it's so pre-alpha that we have to invent a time machine to travel back to the old greeks to tell them they have to invent a new letter to go before alpha :-).
• Phase 1: The system is usable for applications that code their UI stuff in a separate frontend application.
• Phase 2: Separate frontend applications are no longer needed.
• Phase 3 and further: Undefined at the moment.

FAQ

Where can I download the Butler?

Nowhere yet, the code is highly unstable and likely to change at any point so that I don't want to release yet (release early, release often, release buggy, but don't release kludgy).

Where can I download the Translator?

For the time being the Translator is being developed and distributed as part of the Butler package. So it's not downloadable either.

What license do the Butler and the Translator use?

The Butler uses the GNU General Public License. The Translator uses the GNU General Public License too, but it has an exception to the license:

The source code for the library is distributed under the terms of the GNU General Public License, with the following exception: if you link this library against your own program, then you do not need to release the source code for that program. However, any changes that you make to the library itself, or to any native methods upon which the library relies, must be re-distributed in accordance with the terms of the GPL.

This exception is further explained in the DotGNU FAQ.

Can I use <name a FOX library here> with DotGNU?

In theory DotGNU will support all FOX libraries. But it's too early to say we support this or that specific library.