GNUstep/Gorm videos

I uploaded a new video showing a custom palette in Gorm and its use -- isn't it great to code a complex volume dataset visualizer without a line of code ? ^_^

I also cleaned up a bit the main page..

I should probably make a video showing the services in action !

Subtext

Found on Martin Fowler's bliki, an interesting short summary of the OOPSLA'05 conference, along with interesting links. One of them is Subtext, a really cool language / programming environment (you perhaps already encounteered it, it was featured on slashdot some time ago...). Definitely something interesting -- check the demo (flash video) and the researcher's blog. Lots of good points / ideas about what should be a programming environment ;-)

I wonder if we could extend some ideas about ide to really dump the text editing, or at least relay a lot more on metamodels of the code.. Dynamic Aspects seems to head into that direction ;-)

Nokia 770

I received today my new shiny toy, the Nokia 770:



I put online some pictures of it..

First impressions:

• it's light ! yet it doesn't feel "crap" :-)


• the form factor is surprisingly nice (even if coming from a newton I wouldn't mind a (physically) bigger screen)


• applications are a bit slow to start. Hopefully things will improve -- even if as it is it's ok, I wouldn't mind instantaneous starts ;-)


• redrawing is a bit slow too :-/ is it because of X or gnome.. ?


• the screen is absolutely gorgeous !! really beautiful and luminous :-) (the pictures I took don't completely do it justice)


• playing movie is ok (there's a trailer for ice age 2 on the machine), but could be improved..


• lack of pppoe configuration for wifi VPN (or if there is, it's not obvious, but well, I just got it, so I perhaps overlooked something)


• installing a package is easy :-)


• The UI is quite good, as a PDA UI -- definitely better than PocketPC (well, duh..), obviously less good than the newton, but hey, it's not too bad..

So well, overall, I'm quite pleased -- the device is indeed very, very cool. Things can be improved, but it's already quite nice. The UI is ok, even if what I would like to do is (obviously ?) install GNUstep on it, and then modify GNUstep to blend on the Maemo platform (with a possible replacing of maemo in an improbable future). Anyway, as it is running linux, it seems an ideal platform for me -- both for experimenting with etoile/gnustep on a PDA (see a previous post about that, and see what I posted about the newton for what I think is good on a PDA...) and as a good client for the system I'm working on at uni...

I'm not sure if there's a market for a "web tablet" device, but I don't think that the Nokia 770 will only be a "web tablet" anyway :-) -- there's already ports of doom, abiword, the GPE pim stuff, etc.

Nokia has a winner in the linux community I think :-) -- which means that you can expect lots of software for the Nokia, and it already started... It also look like an excellent device for ebooks, administrators (as an X/VNC/ssh terminal), etc.

Yeah

Just finished (completely, as in "theoretically nothing to add") the paper I was working on for wscg.. (they don't even have a LaTeX template, only a Word one (!!), and it is rather ugly imho..)

Hopefully I'll have some more free time now to work on camaelon and étoilé ;-)

Talking about étoilé, Quentin created a blog ! Étoilé dev will use it to rant about the project :-) -- hopefully it will become an interesting news place..

High Order Messaging

Marcel Weiher sent a mail on the objc mailing-list about a paper he wrote (with Stéphane Ducasse) on High Order Messaging. Basically, HOM is a message that takes another message as a parameter -- like in functional language you have High Order Functions that take a function as parameter.

Ok, nice name .. but why is it interesting ? Well, you have lots of cases where it's really neat :-) but the most known is to use it for iterations. Imagine you have an array containing objects, and you want to send to all of them a message. In Objective-C you'd do:

int i;
for (i=0; i<[myArray count]; i++)
{
   id currentElem = [myArray objectAtIndex: i];
   [currentElem aMessage];
}

You could also use an enumerator (NSEnumerator) but that doesn't really simplify things. What's the problem with that ? Well, you have code (the for loop..) that you don't really care about, that is actually always the same, you need to deal with each elements, etc. Basically, the programmer's intent is not immediately clear. And of course, the more code you have, the more you can encounteer bugs... So simplifying this pattern would be great. Well, with HOM you will do:

[[myArray do] aMessage];

Better, no ?

Conceptually, the message "do" takes another message as parameter -- it's a HOM. Here it actually bounces the message to all the elements of the array -- therefore, encapsulating the iteration pattern.

Technically, it's a rather cool usage of the Objective-C runtime -- no need to change anything to your compiler :-) -- the HOM message actually returns a Trampoline object that will get the message send to it via forwardInvocation. Read the paper for a good description.

So, using HOM is great for encapsulating the iteration pattern, ok. But after all, we have the makeObjectsPerformSelector.. so why using HOM ?.. Well, the difference is that YOU can create new HOMs, and you are not limited to the iteration pattern :-)

Another good example from the paper.. You have a delegate object you need to send a message to. You'll have the following code:

if ( [delegate respondsToSelector: @selector(windowDidClose:) ] 
{
  [delegate windowDidClose: self];
}

Again, this is a frequent pattern. Moreover, it's prone to errors -- the selector in the test needs to be equal to the message you send.. An HOM equivalent will be:

[[delegate ifResponds] windowDidClose: self];

Elegant, no ?

Just to finish.. some other examples from the paper:

Starting a method in a thread is done like that in OpenStep:

[NSThread detachNewThreadSelector: @selector(doSomething) 
   toTarget: receiver withObject: nil];

The HOM equivalent:

[[object async] doSomething];

Or say you want to send a message with a delay.. In OpenStep:

[receiver performSelector: @selector(doSomething) 
   withObject: nil afterDelay: 1.0];

With HOM:

[[object afterDelay: 1.0] doSomething];

I remember reading about HOM on Marcel's site before this paper, but this paper is an excellent presentation of the idea and do a great job highlighting the possibilities -- another useful mechanism to add to your toolbox to capture patterns :-)

Many HOM implementations exists (in addition to Marcel's original, MPWFoundation), that you can check on that page

PDA, Dynabook and Etoile

I started to think how Etoile could possibly works on -- and take advantage of -- a PDA or Tablet platform...

With the help of Jesse Ross I wrote this page
on the Etoile's wiki; another related page I wrote is one about the Dynabook

Thoughts ?