ANN: Kamaelia 0.2.0 released!

phil hunt zen19725 at
Wed Aug 3 13:36:04 CEST 2005

On Tue, 02 Aug 2005 11:05:16 +0100, Michael Sparks <michaels at> wrote:
>Phil Hunt wrote:
>> Kamaelia seems it might be an interesting project. However, I don't
>> think the project is well served by this announcement -- which I 
>> find vague and hard to understand. Which is a shame, because it
>> means that other people probably don't understand it very well
>> either, which means less people will use it.
>It is a shame, and thanks for mentioning this. Let me have another
>go :-) (ripping to shreds welcome :)
>OK, here's a better go. (It's always difficult to think where to pitch
>this sort of thing)
>The project aims to make it simple to build networked multimedia
>systems (eg audio, video, interactive systems),

There's plenty of software that facilitates networking, for example 
Python already has software for tcp and http clients/servers, and 
for xmlrpc remote procedure calls.

So what does Kamaelia do that's extra? I imagine it's to to with 
streaming large amounts of data. For example, a streaming video or 
audio player. Or VoIP, perhaps.

> which are naturally
>componentised and naturally concurrent allowing quick and fast reuse in
>the same way as Unix pipelines do. 

OK, so what do the components in the pipelines do? What sort of data 
do they hold? Unix pipelines act on ascii files; I assume you are 
do this on audio and visual data. What langauage will the ele,ments 
in thne pipelines be written it? I assume some will be in C/C++ for 

>It is designed as a practical toolkit, such that you can build systems
>such as:

When you say "you" who do you mean? Is the audience programmers or 
less technical people? A project that allows non-technical people 
to build complex network applications is an ambitious one, but not 
impossible (I'd find it very impressive and very exciting, 
particularly if it runs on devices such as mobile phones).

>   * Ogg Vorbis streaming server/client systems (via vorbissimple)
>   * Simple network aware games (via pygame)
>   * Quickly build TCP based network servers and clients

What sort of servers and clients? Serving what? Could I use it, for 
example, to build a

>   * Quickly build Multicast based network servers and clients

Serving what? Could I use it, for example, to build an n-player 
encrypted (I mean proper encryption here, the sort GCHQ or the NSA 
can't break) VoIP server to allow people to do conference calls over 
the Internet?

>It runs on Linux, Window, Mac OS X with a subset running on Series 60
>The basic underlying metaphor of a component us like an office worker
>with inboxes and outboxes, with deliveries occuring between desks,
>offices, and depts. The component can thus do work anyway it likes but
>only communicates with these inboxes and outboxes. Like office workers,
>components run in parallel, and to achieve this are generally
>implemented using python generators, but can also used threads.

That metaphor brings up an image (at least to me) that the sorts of
data that can be communicated are things like documents,
spreadsheets, business graphs, memos. Also the metaphor doesn't 
indicate any sense of real-time-ness; stuff on an in tray isn't 
immediately processed and moved to the out tray.I'm pretty certain 
that's not what you have in mind. 

May I suggest a different metaphor? Consider a hi-fi system where 
you plug cables in to control the dataflow. For example, an 
unamplified audio signal goes into an amp, the amp has various dials 
and buttons on it, and an amplified signal comes out. Note that the 
signal processing is done in real time. 

Is that the sort of thing you are working on?

>The rationale behind the project is to provide a toolkit enabling the
>development of new protocols, including streaming, for large scale
>media delivery.

OK, I get the straming part of it. But what asbout non-streaming 
stuff? What other protocols are necessary?

> The license essentially allows use in proprietary
>systems without change, but all changes to the system itself must be

Fair enough.

>Is that clearer ? 
>A short summary of all that could be:
>"""Kamaelia is a networking/communications infrastructure for innovative
>multimedia systems. Kamaelia uses a component architecture designed to
>simplify creation and testing of new protocols and large scale media
>delivery systems."""
>Hopefully that's clearer than:
>>>Kamaelia is a collection of Axon components designed for network
>>>protocol experimentation in a single threaded, select based
>>>environment. Axon components are python generators are augmented by
>>>inbox and outbox queues (lists) for communication in a communicating
>>>sequential processes (CSP) like fashion.
>[ which you noted "I really have very little idea what this means." ]

Sort of. But it's still a bit vague. For example:

"networking/communications infrastructure" can mean a lot of things.
It doesn't even specify whether it is hardware or software.

"innovative". This actually has two meanings. One is "is new /
allows new things to be built". Another is "meaningless marketing
buzzword" (half :-)). I assume you mean the former, but some people
may be put off by what sounds like buzzwordspeak.

A good short summary would answer these questions:

* What broad category does the system fall under? Software or 
Hardware? (the answer here is software). For what sort of 
problem-domain? (here the answer is audio and video)

* What sort of software is it? An end product, useful in itself? Or
a library, from which people can build applications?

* Who is it aimed at? Programmers, less-technical users, the genral 

* At what stage of completion is it? This is a question sometimes 
not answered well by open source projects, which can cause 
disappointment if a project is at an earlier stage of development 
than some percieve. And also, a project might have immediate goals 
that are quite modest, and long-term goals that are more ambitious.

>For example, trivial sketches:
>   * A program to display an image using pygame
>   * A program that can understand when an area of space has been
>     clicked. (call it a button)
>   * A program that can print a list of filenames, pausing waiting for a
>     user to press return.  (call it a chooser)
>Trivial changes:
>   * Take the filename of the image from an inbox
>   * Rather than print the filenames to send the filename to an outbox.
>   * Rather than wait for a user to press a key, wait for a message on
>     an inbox.
>A useful composition linking some of these together:
>     CHOOSER = Chooser(items = files),
>     IMAGE = Image(size=(800,600), position=(8,48)),
>     NEXT = Button(caption="Next", msg="NEXT", position=(72,8)),
>     PREVIOUS = Button(caption="Previous", msg="PREV",position=(8,8)),
>     linkages = {
>        ("NEXT","outbox") : ("CHOOSER","inbox"),
>        ("PREVIOUS","outbox") : ("CHOOSER","inbox"),
>        ("CHOOSER","outbox") : ("IMAGE","inbox"),
>     }

That's certainly less lines of code than it would take in Tkinter. 
And easier to follow.

>And you have a simple presentation tool !

Now I'm confused. Is Kamaelia a GUI builder?

>Another example. The visualisation framework was originally a stand
>alone piece of code and was essentially just a piece of eye candy. I
>threw in a few yields into certain locations. File reading & static
>graph construction was replaced with recieving data from inboxes, and
>then it was available for use (and networked after creating trivial
>protocol components).

Ah, so now I'm guessing it allows me to write networked PyGame 
applications, where with just a few lines of code I can have 
networked streaming video on my pyGame screen... am I right?

>A piece of eye candy is now a useful tool. It's likely to gain the
>ability to send to an outbox a message saying "this blob is clicked"
>meaning we can have 'WYSIWYG' GUI based construction of pipelines

That sounds useful.

>Why wouldn't you use it? When Twisted is appropriate (Twisted is a more
>mature framework).

The problem with Twisted, IME, is I don't understand the 

Email: zen19725 at zen dot co dot uk

More information about the Python-list mailing list