Random thoughts of a Camaelon

Some work on GNUstep theme support...

2009-10-19T14:23:00.002+01:00

Quentin came to visit london this weekend, and he thus forced^H^H^H^H^H^Hconvainced me to work again on gnustep, on the theming support. GNUstep had the possibility to use themes using my theme bundle, Camaelon. But this had some technical issues (though we do use it in Étoilé), mostly that it's easy for Camaelon to be out of sync with the current GNUstep implementation. Richard Frith-Macdonald has thus started to implement some theme support directly into GNUstep, and even wrote a theming application to help creating themes. But the support is still limited -- you can change images, colors, and the drawing of some widgets but not all.

Anyway, what I did this weekend was quite a bit of refactoring in the theming code dealing with pixmaps -- things should be much clearer now. I also added an implementation for Nine Patch pixmaps, which basically makes creating custom themes a lot more simple. For example, the following content in a theme's Info-gnustep.plist will be enough -- no need to have multiple files as with Camaelon, no need to measure things...


GSThemeTiles = {
  NSButton = {
    NinePatch = YES;
    FileName = NSButton.tiff
  };
};

With a button made in five minutes of Gimp work (as can be seen!):

An example of the result:

New website

2009-07-06T08:32:00.000+01:00

I finally took the time to redo my website properly :)

Obviously, I had to use Seaside, and as I did play with Pier some time ago, this looked like a good fit.

For those who do not know, Seaside is the best web application server I know of -- it really is something when you want to quickly write extremely complex sites or webapps. Pier is a CMS developped on top of Seaside, which provides a wiki system amongst other things.

The new theme is also frankly much better than my previous one -- it's actually nearly exactly the same as the default Pier theme, but hey, I really like it, and it _is_ cleaner :)

The site also automatically pull the last posts from this blog as well as my last commits and some recent twitter posts, and display all this as the main page.

Finally, one thing that wasn't great on the previous site was the pictures section; I resumed some earlier work I did on a Pier component (Pier Gallery) and cleaned it up to get what's shown now... more on that in a next post.

Automating DxO FilmPack (OSX)

2009-06-29T22:07:00.006+01:00

DxO FilmPack is an awesome set of filters for your pictures, rendering them using classic films -- not just the colors, but the grain as well. It is available either as a standalone application or as a Photoshop plugin.

As an example of what FilmPack can do, here's one picture I took, first the original, then two filtered:

Original:

Fuji Superia 200:

Ilford Pan F Plus 50:

But even though it's really, really cool... it has a rather annoying limitation in its standalone version: you cannot apply a filter to a set of images, you have to apply it image by image. Of course, this might be all you need; but for my part, I would love selecting a type of filter I like and apply it on an entire set of pictures, as if I did shoot them using a film camera.

Hack it

Here is how you can do it, using a mixture of bash and AppleScript. Honestly, this is a hack -- it would be great for it to be integrated in FilmPack directly! but in the meantime, this can be useful...

As expected, the programmers did not bother to provide a scripting interface, so you seemingly cannot script it (it would have been useful for such a program with potential repetitive action, don't you think?).

Or can you ? It turns out that OSX has a rather nifty feature that allow near-global scripting: you can have access to all the GUI objects shown on screen, query their states, etc. It is not active by default -- you need to go (in the System Preferences) to "Universal Access" and click on "Enable access for assistive devices".

So, we starts with a bash script (we can call it "convert.sh"):


#!/bin/bash
for i in `ls *.JPG`;
 do /Applications/DxO\ FilmPack\ 2.app/Contents/MacOS/DxO\ FilmPack\ 2 $i & osascript ./filmpack.script; done

This will, for each jpeg files in the current directory, open the binary executable of FilmPack and passing it the current jpeg as a parameter ($i). Doing this has for effect to start FilmPack and automatically load the image passed. Finally, as soon as FilmPack is started, we execute the filmpack.script.

This filmpack.script is a simple AppleScript:


tell application "System Events"
        tell process "DxO FilmPack 2"
                get enabled of menu item "Save As..." of menu 1 of menu bar item "File" of menu bar 1                
                set frontmost to true
                click menu item "Save As..." of menu 1 of menu bar item "File" of menu bar 1
                click button "Save" of sheet 1 of window "DxO FilmPack 2"
                click menu item "Quit DxO FilmPack 2" of menu 1 of menu bar item "DxO FilmPack 2" of menu bar 1
        end tell
end tell

This script asks the FilmPack application to save the current opened image, and to quit the application.

The only notable trick here is the "get enabled" line -- by asking AppleScript if the "Save As..." menu item is enabled, AppleScript will actually block until it can read the value, which makes the whole operation as fast as can be (no need for a sleep somewhere to wait until FilmPack is fully loaded and/or has applied the filter to the image).

Use it

Now, how to use it? well, let's say you have a directory Pictures containing your pictures. You can copy in that directory both convert.sh and filmpack.script (or alternatively put those files in some default path). Then the last thing you have to do is to "configure" FilmPack once -- it will then remember the settings for the next time it is used. The easiest way to do this is thus to start FilmPack, open one of your picture, choose what kind of filtering you want to do, then save where you want all the pictures to be saved. Then quit FilmPack, and run convert.sh!

Interview Étoilé

2009-02-06T23:16:00.009Z

Me and Quentin were interviewed a few weeks ago by a french linux magazine (Linux Pratique Essentiel), about Étoilé. The magazine is out this month, and the magazine preview shows the article, starting page 24 to page 28...

(note: the title can be translated as "Étoilé, an innovative desktop environment")

Atari

2009-02-03T11:31:00.004Z

Great stories about the creation of the Atari ST: part 1 and part 2. I still remember fondly the ST, TT030 and Falcons... (The TT030 my dad had still works, afaik). I also remember the huge Megafile 30 on top of the MegaST -- an incredible thirty megabytes of disk space ! Why is it that I am now always short on space :)

...and snow in london

2009-02-01T22:54:00.005Z

After the south of France, it's now London's turn...

It apparently did not snow as much in 18 years -- London is very quiet today!

update:

update2, going to work:

Snow in Provence

2009-01-07T11:49:00.005Z

A friend just sent me this picture:

...taken from her window, near Marseilles, south of France. Impressive isn't it ? highway closed, etc.

Usually happens every ten years or so :)

edit: another friend took the following pics:

edit 2: check that video...

A Modern Objective-C Runtime

2009-01-05T11:36:00.003Z

David just got his paper describing his new Objective-C runtime for etoile published in the Journal of Object Technology. Congrats :)

Mona Lisa video

2008-12-11T11:52:00.003Z

Here is a small video demonstrating the polygons evolution:

(better results should be doable with more time and/or more parameters tweakings)
For this example, I used 50 polygons of at most 16 points, starting with 10 polygons.

Genetic Algorithms and Mona Lisa

2008-12-10T23:50:00.003Z

Genetic Algorithms try to apply evolution mechanisms to find solutions to hard problems (typically, where no "proper" solution is known and where the search area is large).

Roger Alsing posted a couple of days ago an extremely cool article showing the convergence of 50 polygons to represent the Mona Lisa, using a random approach.

That was too cool to not try to implement it :)

The screenshot shows a rendering of the Mona Lisa using 50 polygons (16 points each), after 40818 total iterations, with 4577 elected states; the middle image is the original (i.e. the target) and the right image the difference between the current polygon-based image and the target (i.e. a representation of the fitness function).
Underneath was an earlier attempt using ovals instead of polygons.

Now, to be more exact, Roger Alsing's algo is more a hill climber algorithm or possibly a simulated annealing algorithm than a good example of a genetic algorithm; it should be interesting to actually implement a proper genetic algorithm approach (i.e. a population > 1) and see how the convergence rate compares... combining polygons and ovals might also result into interesting things.

Gregynog 2008

2008-11-25T15:04:00.006Z

Gregynog is an annual colloquium organized by Swansea University. I was invited to give a talk yesterday about web, webapps and the evolution of web programming. I uploaded the slides here (PDF) if you want to have a look.

End of an era...

2008-11-20T14:48:00.004Z

A pdf can be downloaded by clicking on the following image:

Factor

2008-10-30T11:43:00.002Z

I just watched this talk:

It's a very nice presentation of the Factor language, a mix of Forth / Lisp / Smalltalk -- a higher level Forth. Interestingly, they do have Cocoa bindings...

Done!

2008-08-20T15:11:00.000+01:00

pending corrections on my thesis, I'm now a Doctor :)

Charlie

2008-07-19T18:02:00.002+01:00

On savait que Philippe Val etait un con (souvenez-vous de ses diatribes debiles sur l'internet), mais il persiste et signe. Minable.

Gears presentation at the Google IO conference

2008-06-19T23:18:00.004+01:00

The videos from Google IO are online, so if you wonder what I'm working on at Google, here is a nice presentation of Gears for Mobile, by Charles and Andrei:

Slides are also available

OpenSource Jam & Literate Programming

2008-05-16T18:33:00.003+01:00

I gave a short talk yesterday about LP at the OpenSource Jam (bi-mensual open source meeting, at the Google London Office). So, here is the pdf of the presentation (just click on the above image to get it). People seemed to like the talk, and there was some interesting comments about the lack of good documentation tools (particularly, the need for multi-level documentations), the similarity with DSL, and some in-house LP tools used by some companies.

update: A blog post describing the event and pictures have been posted by the open source team...

iLiad iRex pictures

2008-05-10T23:35:00.004+01:00

As there's some interest in the iliad and other ebook readers, and as a follow-up to my previous post describing my general impressions of the iliad, I thought that posting some pictures would be interesting... Clicking on the images shows the original image size (note that the grain is in fact due to the iso setting rather than the iliad !)

This first picture shows an A4 PDF, not resized, and perfectly readable. As you can see, no problems either with the viewing angle.

The 16 gray levels work well enough for reading some comics :)

Another comic, close up.

One of the great thing with a reasonable resolution and antialiasing: you CAN put A4 scans of partitions, and IT IS readable :) -- here the Turkish March, from a freely available document scanned by the Bibliotheque Nationale de France (thanks!).

As you can see, the poor quality of the pictures (and the not-so-great white balance) are due to the actual lightning conditions :) -- and you can also see how well an e-ink device reacts to a direct spot lamp...

Finally, as it's one of the main use of my iliad and one of the main reasons I actually bought one, an A4 research paper:

As you can see, it's readable (albeit a bit small), with the PDF reader I use simply set in fullscreen mode.

Zooming on the same document with the camera (ie without touching the iliad) -- you can see how such A4 PDF documents are actually readable, without any kind of resizing (apart the fullscreen mode). The PDF reader application can also zoom the document if it's really necessary (using a simple gesture with the stylus), but I rarely use this feature (usually only for some diagrams if they are too small, not for the text itself).

Thesis

2008-05-06T13:12:00.004+01:00

Feels good :)

Iliad iRex note taking and hand-writing recognition

2008-04-11T04:22:00.003+01:00

I recently bought an Iliad iRex, a pretty awesome eBook reader. Among the cool features, it's running linux, an sdk is available, and it's really easy to hack stuff for it (for instance I wrote a simple script for downloading the 24h edition of The Guardian). Also, as shown with the previous link, the community is quite active :)

Just a couple of words about the iliad itself... the hardware is pretty awesome, with wifi, ethernet, wacom tablet, usb, mmc card and compactflash, audio jack...
the e-ink display is quite amazing too -- 768x1024 makes it precise enough to be able to read A4 PDF without too much problem (a great thing to review lots of research papers, believe me !).

The software side on the other hand... is a bit disappointing. Don't get me wrong: it's good enough, and some aspects are pretty cool. But you really unlock the possibilities of the devices by getting the root access and adding applications developed by the community (notably, the PDF viewer hacked by the community is fantastic, with gestures, etc.). Which means it's fine if you are a geek and not afraid to hack your device, but more annoying for your average consumer :-/
The other disappointing aspect is the (comparatively) low battery life: about 12-15 hours depending on the model (mine is a v1, the v2 do better), which is mostly caused by the fact that no sleep mode is available. Other eBook readers perform much better on that metric. To be fair they don't have wifi nor a wacom tablet :D ... so it's really a matter of choice.

All in all, it's a bit of a shame as really the platform is very nice, and with a bit more effort on the software side, Iliad would have a killer product on their hands. Oh, and yes the e-ink display refresh rate is slow, but curiously it's not that annoying, and having its full library in such small factor is absolutely fantastic.

Anyway... one of the really, really cool feature of the iliad is the presence of a stylus (i.e. the iliad display sports a wacom tablet), which allows you to annotate PDFs, take notes, etc.

I started to experiment a bit with the note taking feature of the iliad; the idea is that you can open a PNG image in the notes folder, and a copy will automatically be made where you can write on it (the image is being used as a background, so it's trivial to have customized backgrounds). But I then wanted to generate a PDF from those notes (i.e. combining the scribbles+PNG).

Iliad do provide a windows application to do all that, but it's a windows app, not really useful for me... there is a nice java application written by the community that allows merging scribbles with the PDF as well. Alas, the java scribble merging application only seems to work for PDF scribble; I guess it would be trivial to modify the java app, but I had a look at the xml scribbling format, and I saw that the format was really simple.

So I quickly wrote myself a MacOSX viewer for the notes, using the png image as a background, letting me print notes easily or convert them to PDF.

But then... I suddenly remembered the Ink handwriting recognition engine.

This thing comes straight from the ill-fated Apple Newton PDA (such a loss!), but what is nice is that it is available and installed by default on OSX.

Turns out it's not too difficult to feed Ink a set of custom datapoints, and after some tweaking it doesn't work too bad apparently, as can be seen on the screenshot...

So far, this is only highly experimental code, and it'll probably take a bit more time to have a really usable application. Still, pretty cool!

DabbleDB 8 minutes demo

2008-04-03T00:42:00.005+01:00

DabbleDB is as impressive as ever. If you never heard about it, it's a fantastic database app, one of the few "webapp" that really manages to be as usable as it would be if it was a "normal" desktop app. It manages that by leveraging the power of Seaside, a web application server written in Smalltalk (hands down the best app server I ever seen, period. Beats even webobjects, and you code in Smalltalk. Can't be better, really!).

Discarding the impressive "webapp" aspect (which in a way is more of a sad commentary on the poor capacities of the "web" platform, although it is improving, as dabbledb can show, and as addons such as Gears improve the capacities), it's the only database I know that let you evolve your data model as smoothly as they do it, not even talking about the great tools to easily explore and enrich your data... This is a kind of flexibility that I think should be put back at the center of our computing experience and be adopted by more applications/domains.

Anyway, Avi Bryant released a new 8 minutes demo showing off DabbleDB, after their famous 7 minutes demo they did in 2006. If you never heard about DabbleDB, check it!

GNUstep Summer of Code 2008

2008-03-27T00:21:00.007Z

For those who don't know yet... GNUstep is one of the organisation that Google has accepted for the Summer of Code program --- which means that if you are a student looking for something to do this summer, want to hack Objective-C code, help a cool free software project, learn a lot... and even be paid, well, you should apply ! sure beat your average summer job :)

...

Deadline for applications is next monday (31/03/2008), so hurry up !

update: the deadline has been pushed by a week, so if you thought you missed it, you still have a few days left to apply.

Mobile Gears T-Shirt

2008-03-23T14:11:00.004Z

T-shirts are nearly an internal currency at work... so we of course had a mobile gears T-Shirt made ! Here is it:

Nice isn't it ?

Hilarious

2008-03-23T14:06:00.001Z

This is just too funny. Hail the Flying Spaghetti Monster !

Google Gears Mobile

2008-03-06T23:04:00.007Z

One of the few annoying things when you work at Google is that you can't really talk with your outside friends about what you are doing... so it's rather nice when you finally release the project you worked on for the last few months and be able to point to it :)

So anyway... we released Google Gears for Mobile tuesday morning ! Here is the post from Charles Wiles announcing it, another one describing mobile gears, and one on the Desktop Gears blog. Plus you get fancy videos from Charles, Andrei and Dave talking about it.

A few words about Gears: it's an opensource project, adding a cool set of javascript APIs to internet browsers. Those APIs let your website use a database locally, cache pages, and execute javascript code in threads, basically blurring the line between webapps and native apps.

Biggest use so far is enabling sites to be used while not being connected to internet. Of course, disconnected mode and local storage make even more sense on a mobile device than for a laptop... add to that the fact that writing native applications for mobile devices is a pain, and gears-enabled "webapps" are suddenly very attracting, even if on winmo you have to go through some gymnastic around PocketIE "limitations". Oh, and this work for the moment on Windows Mobile 5 and 6, touchscreen and smartphone, and implements all the 0.2 APIs of the desktop gears.

And more is coming...

Evolved Virtual Creatures

2007-09-23T16:35:00.000+01:00

A pretty cool video showing evolved virtual creatures:

More infos here, with Karl Sims Siggraph's 1994 paper..

another video from Nicolas Lassabe

Cairo backend

2007-09-09T19:03:00.000+01:00

Just a quick note: Fred Kiefer fixed the last issue I had (bad text clipping / smearing) with the Cairo backend... so, no more little glitches, it's really usable now !

Dock

2007-09-04T21:43:00.000+01:00

Looks like it didn't take long for Yen-ju to play with the Cairo backend and partial transparency :)

Shiny. (yes, too much like OS X)

GNUstep Cairo backend

2007-09-04T03:15:00.001+01:00

After some effort, I finally managed to find a solution to the annoying scrolling bug in the Cairo backend... There's still some little graphic glitches appearing sometimes -- it looks like some clipping/refresh issues -- but overall it's nearly there :)

For the intrepid, the code is committed on the gnustep trunk. The above screenshot shows the Etoile desktop (with the new compositing manager) and the work-in-progress Narcissus theme, running with the Cairo backend.

AlpenStep '07

2007-09-02T23:49:00.001+01:00

I was at AlpenStep this weekend, you can check some pictures.

It was a very cool event, thanks in particular to gerold's organisation. The location, in a small swiss village, was really nice -- I can say that some fresh air after beeing in london is good !

It was also a small-scale event -- only 7 persons (though gurkan came but left saturday before lunch :-/), which made it a very intensive event as well: lots of discussion, lots of coding too. Fred Kiefer was probably the busiest person in the room, as everybody wanted to ask him questions/advices... ;-)

Riccardo Mottola gave a nice GAP demonstration, and during the weekend he and Nikolaus Schaller were busy working on SimpleWebKit:

Nikolaus also made a cool presentation of QuantumSTEP running on the OpenMoko platform :)

The OpenMoko device is actually fairly nice, very high-res screen, and some interesting hardware to tinker with.

Quentin was working on ContainerKit for Etoile, a very interesting way of specifying UI using a generic data model (so you can switch representations on the fly for instance), also allowing very nice introspection features with inspectors generated on the fly. I tried to convaince him to introduce some Magritte-like magic, i.e. adding metadatas to your model...

Quentin and I also made a presention of Etoile, describing the various components/frameworks/applications, and how everything is supposed to fit...

Finally, I can only be admirative of gerold organisation skills... to the point were he got us a GNUstep cake:

Which was delicious !

In short, looking forward for AlpenStep'08 ! (and Fosdem'08 before...)

Cairo/GNUstep

2007-09-02T15:27:00.000+01:00

I was at AlpenStep this weekend (photos will follow..) which was quite cool. I teamed with Fred Kiefer (the GNUstep gui maintainer) to try to iron out some of the quirks of the Cairo backend. The main problem (recopy of surfaces is not always done well, which impact scrolling) is still here, although we improved some things, and it looks now like it should be solvable with a bit more work. We also added 32 bit surface support when choosing x11 visuals : a cool side-effect is that you can then use directly the alpha channel on the window :) and thus draw semi-transparent windows.

David will like that ;-) -- he's working at the moment on Etoile's compositing manager...

In the above screenshot, I simply fill the view with NSCompositeClear (so it's just transparent), and then composite an image on it, with 0.8 transparency. You can then see that parts of the window are fully solid, while some are completely transparent, and others partially transparent.

Et merde.

2007-05-06T22:18:00.000+01:00

On est pas sorti de l'auberge maintenant. Ca donne pas envie de revenir en france en tout cas... :-/

Resultats de l'election presidentielle

Hard Disk Crash

2007-04-28T19:21:00.000+01:00

...You know when people tell you to do backups ? Feeling guilty ? :-)

Well, most of my data is usually backed up, but... even so, there's still a lag usually, particularly for "not-so-important data", etc. Add to this usual mix some data put away "temporarily" from my main computer... and that's when my LaCie 250Gb external drive choose to die. Around 200Gb of data lost, among them some that I could get back with various difficulty somewhere else, eg on some dvd or other computers (the LaCie *was* the main/more used backup plan), and some truly lost (yes, this "temporarily moved" data, yes, it's you I'm talking about), or some data recently copied only on the LaCie... Of course this drive is around 3 years old, and I actually had some thoughts recently of doing a proper backup of everything there was on it, for convenience, and for fear of such an accident. Of course too, I ended up way too busy to actually do it...

Still, a bit of luck: there was no scratching noise, in fact, there wasn't any noise at all: the disk just didn't start, which meant that it was more likely an electronic fault than a mechanical one. Removing the hdd from the LaCie enclosure and plugging it directly on a computer didn't do anything either (so it sadly wasn't the LaCie controller board). So that left us with the actual hdd electronic board... I then looked on the web for an hdd from the same brand and the same model -- and found a cheap one from an online reseller. After receiving it, I checked it -- yes, it was the same model, yes, the same year, yes the same firmware... ah. No. not the same firmware ! well, still, only two months separated those drives, so I crossed my fingers and started removing the controlling board of the "new" drive to swap it with the one on my crashed drive. Never having done that, I wasn't quite sure what to expect :-) but it's in fact really straightforward (you just need the right kind of screwdrivers -- Torx). The only difficulty is in finding a control board that is compatible with your hdd!

To cut the story short, the "patched" drive started happily and worked fine, so I passed the day swapping and burning dvd of the drive's content ;-)

One thing for sure is that I will seriously think of building a proper backup solution (ie, automated/redundant) for hosting "home" data (photos, videos, music...) asap... I was lucky to save this drive ! these kind of content is annoying as they quickly take so much space, yet (for at least some of them) they are invaluable...

NeXT videos & WebObjects

2007-03-24T09:00:00.000Z

I found these two videos, the first one showing Steve Jobs demo NeXTstep 2.0, the NeXTCube 040 + Dimension, the slab, DBKit, in 1990.. it's always surprising to see how far ahead NeXT was, or reversely, how slowly did we progress on the software side, while the hardware we have now is insanely more powerful...

The second one shows again Steve Jobs, five years later. NeXT stations didn't sell, their state-of-the-art factory closed, they stopped producing hardware, and reconverted as a software only company. The tone of the talk seems to reflect those disappointment, with Steve trying to be excited about Distributed OLE and Portable Distributed Object (PDO), but you can feel it's not really anymore about changing the world... and yet, when analysing the state of the WWW and its future, Steve is absolutely dead on, and he then goes on to demo a beta version of WebObjects, which in the end will save the company (until it took over Apple). WebObjects was an absolutely amazing tech, and still is. The move to a J2EE implementation instead of the ObjC implementation, the availability of other solutions, and its curious downplay by Apple (while they use it for their store, they aren't exactly pushing it on the market, although they dramatically cut the price from hundred thousands of dollars to $500, to finally make it free). WebObjects had a huge impact on current "web application servers", many of them openly inspired by it. My preferred one is Seaside, a fantastic Smalltalk framework... for a great example of what you can do with Seaside, try dabbledb :-)

Note that there's two free software implementations of WebObjects in Objective-C, GNUstepWeb and NGObjWeb (part of SOPE, the web application framework used by Opengroupware.org).

GNUstep participates in Google Summer of Code 2007

2007-03-16T13:36:00.001Z

The GNUstep project just announced that it was accepted in the Google Summer of Code 2007 :

GNUstep provides a cross-platform solution for Objective-C/OpenStep/Cocoa developers. This year, it offers various projects for SoC, such as adding new classes from Mac OSX 10.4, enhancing text system, porting WebKit to GNUstep, improve GNUstep on MS Windows platform, etc. It is a great chance for students to learn programming in many aspects.

read more | digg story

It's an excellent news ! we tried to be accepted first two years ago if I remember, and last year we were in but under the GNU umbrella... and no projects were accepted. Beeing accepted as a separate organisation should help us, hopefully !

Beside, any progresses on GNUstep will be immediately useful for Étoilé :-)

If you are a student, it's definitely worth a look -- GNUstep is one of the best OO api available here, and a fun place to hack.

update: Squeak is also in ! :-) great news too...

Pink Floyd

2007-03-01T22:59:00.000Z

Today I was in london for a job interview, and had a few hours to kill after it before going back to wales.. so I walked around a bit, and ended up reaching the Thames (duh! not surprising in london, is it ?). But I just ended up in front of the Battersea Power Station :

Of course, this power station is world famous because of Animals, the 1977 Pink Floyd album... ;-)

Sadly, I didn't have my camera with me, so the shots are from my mobile... here's some more:

ps: in the "cool for a geek dpt", I'm actually posting that from my laptop.. but through my 3G mobile cnx. With a cheap unlimited data plan, you basically get internet access everywhere -- as like here, in the train :D

Fun with Objective-C

2007-01-19T17:56:00.000Z

Following a mail from david on étoilé dev about how it could be nice to try allocating ObjC objects on the stack, I played with a couple of things...

First I wrote a mini benchmark -- get a very basic object (a couple of ivars, one method "plop" assigning a value to an ivar), and then create an instance, initialize it (call the init method), call the one method the object has, then deallocate the object. 10000000 times. As far as micro benchark goes this one is pretty stupid but well, that'll give us some ideas of what's going on.

Without optimizations: ~4.10s (on a macbook pro 2.16Ghz, core duo)

Not that great -- doing the same thing in C++ with a similar object here is the timings I get:

Objects created on the stack: 0.24s (17 times faster !)
Objects created on the heap: 1.37s (3 times faster)

Ouch, the poor Objective-C... not a surprise when allocating objects on the stack, but even allocating them on the heap C++ is still 3 times faster.

One obvious reason is that Objective-C calls a lot of methods when creating an object; and a method call is more costly than a C++ function call. Still...

So the obvious idea here is to cache some method calls (ask their address then call the function directly -- as a C function). I restrained myself to alloc/init, the method the object had ("plop"), and the release method. Of course, there's other methods that are called by those, that won't be cached.

Caching method calls: 2.77s

It's still twice as slow as creating the C++ object on the heap, but it's anyway a nice performance increase.

Ok, then our only option left is to allocate the Objective-C object on the stack. Surprise:

ObjC objects created on the stack: 0.23s
ObjC objects created on the stack + cached imps: 0.13s

:-)

[note of course that it's a stupid micro-benchmark that doesn't prove much, but it's fun]

...

What ? how can you allocate objective-c objects on the stack ? ah well... you can:


#define STACKCLASS(class) typedef struct { @defs(class) } \
    __CLASS_ON_STACK__ ## class;


#define STACKOBJECTISA(objectName,className,classIsa) \
    __CLASS_ON_STACK__ ## className __INSTANCE_ON_STACK__ ## objectName; \
    __INSTANCE_ON_STACK__ ## objectName.isa = classIsa; \
    className* objectName = (className*)& __INSTANCE_ON_STACK__ ## objectName;


#define STACKOBJECT(objectName,className) \
    STACKOBJECTISA(objectName,className,[className class]);

Here is an example:


STACKCLASS(Test);

int i;
for (i=0; i< 10000000; i++)
{
  STACKOBJECT(test,Test);
  [test init];
  [test plop];
}

Basically, create the corresponding struct for the class and set the isa member (you can also cache the class isa to gain one message send). A bit of a hack, but that seem to work ok :)

Note of course that by doing that, you loose flexibility -- exit class clusters for instance (eg classes that actually returns another class instance, such as NSNumber), you can only work with concrete classes. And also, don't call directly -dealloc as it would try to deallocate the object, which is not needed as it was created on the stack (so if you need to do some cleanup you should do it in another method).

Here's the macros I used for imp caching (fairly straightforward):


#define CALLIMP(imp,object,sel,args...) \
    (*imp)(object, @selector(sel) , ##args)
#define GETIMP(class,sel) [class methodForSelector: @selector(sel)];

You use them like that:


IMP imp1 = GETIMP(Test,alloc);
id p = [Test new];
IMP imp2 = GETIMP(p,init);
IMP imp3 = GETIMP(p,plop);
IMP imp4 = GETIMP(p,release);
[p release];

int i;
for (i=0; i< 10000000; i++)
{
   id test = CALLIMP (imp1, c, alloc);
   CALLIMP (imp2, test, init);
   CALLIMP (imp4, test, plop);
   CALLIMP (imp3, test, release);
}

Pointillist

2006-12-04T00:17:00.000Z

What is it ? well, Pointillism is a style of painting I quite like, but Pointillist is simply the (working) name of a small graph library I'm working on. The previous post was discussing about the simulation software I wrote, which uses a simple graph view. I decided to clean up a bit that view, put it in a framework and commit it somewhere (likely on the étoilé repository). Not quite done yet, but it's shaping well, and it's now quite a bit more generic:

One of my "I will do it one day" project is a simple graph calculator... So in order to properly test the graph framework, I created a class using the StepTalk scripting framework to express functions (written in Smalltalk), which actually makes me rather close to have such a program :-P

for the curious, the code of the functions is:

Red function:


|y| 
y := -0.5. 
((x < 0.5) and: (x > -0.5)) ifTrue: [y := 1]. 
(x < -1) ifTrue: [ y := 0.25]. 
( x < -1.5) ifTrue: [ y := -2 ]. 
(x > 1.5) ifTrue: [ y := 2]. 
y := y + 1.5. 
^y

Green function:

x sin - 1 / x

Blue function:


|y mod| 
y := -1. 
mod := x mod: 2. 
(mod = 0) ifTrue: [ y := 1 ]. 
y := y - 2. 
^ y

StepTalk is really cool btw -- Easy to integrate, and works both on OSX and GNUstep. Here is the code I use here:


id environment = [STEnvironment environmentWithDefaultDescription];
id conversation = [STConversation conversationWithEnvironment: environment
      language: @"Smalltalk"];

(...)

id number = [NSNumber numberWithFloat: x];
[environment setObject: number forName: @"x"];
[conversation interpretScript: @"^ (x tan) / (x atan)"];
id result = [conversation result];

[values addObject: result];

values beeing a NSMutableArray containing the numbers returned by the steptalk function (the ^ in smalltalk is equivalent to a "return" statement in C). As you can see, difficult to have a scripting framework simpler than that to work with!

You can see that in the environment object I put an "external" (to the script) object, number, and this object can be accessed from the script using the given name (here, x). You could, instead of getting the script result, get the value of specific objects you put in the environment.

Anyway, it's very simple to add StepTalk support to your program, and recent versions even add nifty UI widgets to play with scripts.. also, StepTalk is not "just" a Smalltalk scripting framework : it can actually use other languages. On GNUstep for instance there's an Io bundle, so you could use Io instead of Smalltalk, etc. (it's actually fairly easy to add languages to StepTalk).

Note also that StepTalk automatically bridge the numbers in the script to actual NSNumber instances... which is how I decided to implement the math functions, and this actually demonstrate a very cool Objective-C feature; NSNumber doesn't have thoses sin,cos,mod.. math functions; so in another programming language we'd be stuck. A "normal" solution could be to modify StepTalk so that it would use something else than NSNumber (say, a custom class of ours), or reversely, to add those functions to NSNumber and recompile -- wait! you could do that with GNUstep (because we have the source), but certainly not with Cocoa on OSX. So how comes it works ?

Well, Objective-C has this great feature: categories. A Category lets you add new code to an existing class, at runtime. So that's simply what I did here -- I created a category on NSNumber with my specific math functions. Without needing to have access to the NSNumber source, or to recompile Foundation. Isn't it great ?

System simulation

2006-11-26T17:41:00.000Z

I'm (rather predictably) still working on my distributed rendering system.. but as it's a bit tiresome to make some modifications, recompile, restart.. -- more importantly, that it takes time to do so (1), I wrote a simple and nice simulation program that let me try different rendering/clustering strategies easily, swap them, evaluate or compare them, etc. That way I can concentrate on them rather than waiting 5-10 minutes to start visualizing a one gigabyte dataset on the cluster. Even better, the final idea is to integrate the simulation in the real system (it actually already gets timings from the real one and extrapolate the results) in order to have a nice feedback loop: run things, keep simulations in parallel, switch to other strategies if the simulation says it's better, update timings if needed, etc. Here is a screenshot of the current program:

The screenshot shows three simulated clustering strategies; basically we want to render an image using multiple computers. Each computer having one or more rendering agent. We divide the image in tiles and the rendering agents' job is to render them, send them back to the clustering agent, which will recompose the final image to send it back to a visualisation client. It's a fairly straightforward distributed technic. What's more interesting here is that we have three different strategies defining which tiles are sent to which agent. The simplest one is to divide the total number of tiles by the number of agents, and send continuous tiles up to that number for each agent (second bottom figure -- each color represents one agent). Another is to alternate tiles (eg no consecutive tiles are sent). Another one is to break the tiles according the the image complexity (first bottom left figure). The image complexity beeing the time each tile took to be renderered (bottom right figure).

The graphic shows the evolution of these three strategies depending on the number of agents. We can see that the alternate tiles strategy works fairly well usually (because the complexity is more evenly distributed), unless we ends on a multiple of the width (16), meaning the tiles are aligned, and thus the complexity is not properly distributed. Having a simulator can let us choose which strategy is the best before having to really use it.

(1) which break one of my Rules of Programming, ie, keep the REPL (Read-Eval-Print-Loop) cycle as short as possible: as obviously the shortest it is, the more ideas you can try.

e-book

2006-10-15T17:55:00.000+01:00

I just read that article about the new Sony's e-book reader (from the osnews story). That made me think a bit about e-book.

I would love to have a "true" ebook. For what ? well, in my case, for reading technical documentation and research papers, possibly some websites. Another excellent usage would be to read newspapers and magazines, or research journals. Or if you are a student, another really obvious target are textbooks. And think about the manga/comics market.

Why would it be interesting to have an ebook for all that ? What's the pattern ? Simply, it's the volume: in all these use cases, you end up with lots of paper very easily (and in a short time frame), and having one device to gather everything would be nice.

But books ? books do not really have a volume problem -- most persons do not read or carry dozen of books at the same time, and the minor inconvenience to carry 2-3 books for a very long journey is not enough to warrant paying premium to have an ebook. Sure, if you have a device able to read pdf and newspapers, it can handles a book, so you'll have books too of course. Having your whole library in one device could be appealing to some too, I guess. But if the main advantage of an ebook reader is answering the "volume" problem, then it means books almost certainly shouldn't be the main target.

So if books aren't (or should not be) the real target, and if things like documentation, newspapers, textbooks are, what does it mean ? Well, it means your device should provide the same features you'd expect from paper when dealing with these. Specifically, you absolutely need annotation. But more than annotation, the device shouldn't be content to only be "as good as paper" -- if you want people to buy it, you need to be better. An obvious candidate feature (come on, we are talking about electronic documents) is to provide a much better way to manage your document collection. Things like searching, grouping, sorting, adding whatever annotation/metadata you want, do specific things that use these categories (like marking some documents, pages or text to be sent to somebody else via email, etc)...

Then, you will have something that people (and companies, and schools) might be interested in.

The screen technology is imho nearly irrelevant, as long as the battery life is good enough (~7-8 hours in continuous usage) and with a good enough resolution. While e-ink is extremely interesting and answers perfectly the battery/resolution problem, it's too slow for the moment (it's also black and white, not absolutely dramatic but something that reduce a bit its impact). Between an e-ink display and a high resolution lcd screen, even if the battery life would be much shorter on the device with the lcd screen, if it provides the kind of characteristics I described above, I will definitely choose it over the e-ink display, and I bet that many persons would do just the same.

Right now, the sony ebook looks more like a solution looking for a problem than anything else, and they focus their efforts on the wrong side (books).

They fail at everything I described above: it's slow to navigate, management of your documents seems inexistant, pdf aren't even there apparently (seriously!), no annotations... the only good thing (while not perfect) is the e-ink display, but they seem to think it's enough. It's not.

If I had money (and time) and more electronic skills I'd definitely want to create a good e-book device. Why not something based on gumstix + a high resolution lcd screen. There's a market waiting to be picked here.

edit: to be fair, checking the sony page they indicate that the device actually CAN read pdf and doc... But only after converting them to the proprietary format Sony uses. Crap ! :D (oh and it plays AAC and MP3 too)

Pfff...

2006-09-01T21:57:00.000+01:00

I finally finished writing the last remaining things for my system, integrated everything, and could generate the data for the paper just in time... That was a hell of a week, but at least this deadline is over now ! I'll sleep a bit :-P

I will also try to resume a minimum my gnustep's activity next week (been more than a couple of months it's on hold) -- I have a couple of things to do that shouldn't take much time from me and that would be rather welcomed :-P

UDP ...

2006-07-06T22:58:00.000+01:00

Well, I'm not working much on anything related to GNUstep/étoilé lately -- I have my thesis to write for december, which also means I need to finish properly my visualisation system soon...

I changed completely the communication stack -- exit XMLRPC/TCP, welcome lossy UDP communication -- good things, it enables broadcast and low latency, bad things... well, using broadcast as an asset, you need to change quite a lot the way you think your program. But it's worth it: not only the end result (the visualization) can be broadcasted, which is nice, but moreover, the rendering process itself can take advantage of broadcasting to be more efficient. Anyway. Here is a screenshot showing a broadcasted MIP visualization of the CThead dataset:

The rendering itself is done on a cluster connected to these 3 machines through a simple udp tunnel. Works quite well..

Flow, State and Persistence

2006-05-19T20:04:00.000+01:00

I gave a talk today discussing state and persistence in your work environment, for the No Grownups Seminar Series.. Here is a flash version of the talk, and here is the pdf one. Have a look !

RTFD

2006-05-11T22:52:00.000+01:00

Well, I was idly thinking that I could move the HTML parsing code of HelpViewer in a GNUstep TextConverter bundle (so that *any* application using text would be automagically able to load html... or at leas the particular HelpViewer brand ;-), so I looked into the RTF TextConverter to see how that worked. It's fairly simple in fact :-)

But reading the code, I also realized that adding RTFD support (RTFD are basically RTF documents + Images) would be trivial. I am actually fairly surprised nobody did that before, particularly as I remember numerous complaint about its non-existence :-/

So, I modified the RTF parser to deal with the \NeXTGraphic tag, and it seem to work well -- at least reading RTFD documents that come from Mac OS X. Though, the actual grammar I used for dealing with it is pretty crude, so I wouldn't be surprised if some documents do not work (likely old NeXT documents... OS X documents produced by TextEdit seem fairly consistent with what I did). Anyway now the basic support is done, tweaking the grammar won't be difficult if it's needed.

Here is a screenshot showing two documents opened in Ink.app (and obviously no modifications were needed in Ink.app...):

It's committed on the gnustep repository, so you can try it by updating and reinstalling the RTF TextConverter bundle.

I'm thinking I'll perhaps commit my actual HelpViewer version (as it can use rtf files) without waiting for the html parser to be finished... plus "commit early commit often" is a good idea ;-) (which I don't follow enough...)

We could write a simple Text editor dealing with links, etc. as well. Oh well we'll see.. :-)

It doesn't hurt...

2006-05-10T00:49:00.000+01:00

Things move quickly with etoile, so here's another screenshot... note that the shadows are ok now with xcompmgr and Azalea+EtoileMenu, that the menu items aren't displaced anymore, and that the info panel was updated (yeah, yeah, it doesn't improve the experience, but it's nice to have ^_^). Saso even added a small animation when you click on the etoile logo in the middle... pfff! ;-)

Anyway, time to work on helpviewer.

Etoile screenshot

2006-05-07T14:19:00.000+01:00

Just for fun.. Here is a current screenshot of etoile, showing the EtoileMenuServer, Azalea (the windowmanager), Nesedah (the theme) and HelpViewer... Things start to work together ;-) [note that the shadow should not/will not appear under the helpviewer menu item...]

Helpviewer and Help System in GNUstep

2006-05-03T16:44:00.000+01:00

I -- finally !! -- started reworking on helpviewer lately -- as the last official version (0.3) doesn't work properly with gnustep (due to changes in GSHTMLParser...). The first goal was to have something working again -- that was fairly easy, by replacing GSHTMLParser by GSXMLParser. Though, it meant that you couldn't use single tags like "br", as you (obviously) need to close them in xml.

I then decided to more or less deprecate the hold "help" xmlish document format and its custom tags, and implement an xhtml parser instead, and while I was here, by using NSXMLParser rather than GSXMLParser.

Exit "intelligent" tags that deal with figures or references, but on the other hand we can reuse html documents -- eg it's probably easier to write documents now than it was with the previous custom xml tags, as you should be able to use standard html editor... or if you want to write your documents by hand, well, html is a slightly more known format anyway !

As we remove "dynamic" behavior, we need to have document completely generated beforehand; eg it will be the document creator application's duty (or the writer) to generate proper references, etc. And yes I somehow plan to write such an editor, but in the meantime you'll be able to easily write/convert your existing html documentation anyway ;-)

Though I'm not entirely fixed -- some of those dynamic behaviour could be coded as specific div tags after all...

Anyway, the importance for the help is to be displayed in the same, standard way. So basically at the moment it's a bit like if helpviewer would provide its own css style to display documentation, that you can't change.

Another feature that need to be added is a proper search function using indexation (LuceneKit, here we are !). Didn't do anything about that yet, but I will probably write a command line tool that take a help document, generate an index and put the index in the document..

So.. apart from ditching the old xml format to use more common html tags name, what changed ? Well, the structure of the help document changed quite a bit too :-)

Before, a help document was basically a bundle (==a folder) containing .xlp files (xml files using the previous syntax) and other resources (images). One file was mandatory, "main.xlp", that was loaded by default; other files were loaded following links written in main.xlp.

Now, it's different :-)

A help document is still a bundle, obviously -- what better way to distribute a help file : you can have various resources in various languages, all in the same place !

But the organisation inside is different. The document can still be segmented in multiple files (now html files), but the structure of the document simply reflect the actual content of the bundle -- eg helpviewer will simply show you the files and directories contained in the bundle. Directories act as a way of having different parts in a document, as they contain other html files. You can (actually it's mandatory for the moment, although I will support /not/ having an index.plist) use an index.plist to choose which file/directory is displayed in helpviewer, and with which name, and in which order. The index.plist file contains a simple ascii plist containing a list of key values, where keys are the filenames and values are the displayed names.

Of course, you can still use links in the html documents too, but the actual structure of the document doesn't depend on that.

One nice thing with it is that you are not at all tied to html documents -- in fact, the first thing I implemented was an "txt" document and later on a "rtf" document (a shame rtfd doesn't work). And anyway I find this new structure much cleaner and simpler...

So... what's the plan now ? Well, I ported nearly all the previously existing functionalities to the new parser (links, etc), so once it's done and usable, I will commit a 0.4 version on the étoilé repository; then it will be nice to add proper support for search/indexing using LuceneKit. After that... well, what would be good to do, is to modify gnustep to have NSHelpManager directly use something like helpviewer -- eg, instead of using helpviewer as a separate application, you'll find the same functionalities of helpviewer, directly in a NSHelpPanel, so that help acts as "private" to an application, like it did on openstep. Probably the good approach would be to modify gnustep to easily support bundles to implement this kind of additional behavior (actually, very similar to GSAppKitUserBundles, but.. I don't know, something perhaps slightly more formalized..), and code such a bundle :-)

After all that, I'd like to rework on my "semantic" editor, and extend it to a nice document (and help) writer. We'll see...

Camaelon Themes

2006-03-14T15:34:00.000Z

I am quite impressed that even without any specific documentation explaining how to do a theme, people are willing to create them:

two new themes for Camaelon recently appeared... Check here for a list.

Very cool.

GNUstep / Fosdem 2006

2006-03-05T22:43:00.000Z

This year's Fosdem was, as usual, really cool and quite busy :-)

Here is a page with some pictures, slides and videos of the gnustep talks: http://www.xdev.org/fosdem2006. I'll upload the rest of the videos probably during the next week...

Foundation

2006-01-26T19:20:00.000Z

After some efforts, I had everything compiled -- ffcall, foundation, appkit, etc. for the nokia. But then my test program crashed :-)

Removing extra libs (hm.. ffcall.. :-/ ) I have something working though: Foundation !

[ note that I got the NXConstantString error, so it looks like library loading order matters (lobjc / lgnustep-base)... changing the ordering in the makefiles make it works though ]

Now.. I compiled gnustep-gui and gnustep-back, both with xlib and art. But the xlib backend crash (it can't find any available font on the nokia apparently..), and the art backend (after some efforts -- #ifdef XSHM to get rid of any XShm calls...) "nearly" works: with my test application (a simple info panel) it displays a window, but without any content (plain white), and complains about bad window... Yet it seems to receive events (I can click on the invisible buttons ;-) so it looks like some art display problem, perhaps just because the nokia uses a non conventional color ordering / depth.

Well I need to come back on ffcall and check if it's the culprit or not for the crashing thing -- having ffcall won't be bad for the gui :-) and try to understand what's wrong with backart... but all in all things progress ;-)

ah, I also did a very stupid mistake the other day, compiling gcc for arm-softfloat. Naively I thought you needed a soft fp implementation, as the arm doesn't have a hardware fp. But what I didn't know is that there's two kind of soft fp -- kernel and softfloat. Worse, you can't link binaries compiled with different fp emulation. And of course, the nokia is compiled with kernel fp emulation, not arm-softfloat.. So I was good for recompiling gcc ...

Though, one good thing is that with arm-softfloat ffcall didn't compile at all (seems that the asm bits of ffcall uses the fp registers for the arm platform), while now it compiles (but as I said it seemed to be the cause of the program's crash, so it's perhaps not as encouraging as it seems ^_^ -- although I need to double-check and recompile things nicely). Considering libffi closures don't work on the arm, if ffcall works that's a good thing :)

Anyway as soon as I have something working decently I'll post a full guide to cross-compile GNUstep on the nokia (and probably some binary packages too if you just want to install it on the nokia).

Nokia 770 + Objective-C

2006-01-25T17:54:00.000Z

I finally had the time to try to do something with the Nokia 770.. and ended up with a gcc + objective-c support that can cross compile for the arm processor. I simply used crosstool with the following script:


#!/bin/sh
set -ex
TARBALLS_DIR=$HOME/downloads
RESULT_TOP=/opt/crosstool
export TARBALLS_DIR RESULT_TOP
GCC_LANGUAGES="c,objc"
export GCC_LANGUAGES

# Really, you should do the mkdir before running this,
# and chown /opt/crosstool to yourself so you don't need to run as root.
mkdir -p $RESULT_TOP

# Build the toolchain.  Takes a couple hours and a couple gigabytes.

#eval `cat arm-softfloat.dat gcc-3.3.3-glibc-2.3.2.dat` sh all.sh --notest
#eval `cat arm-softfloat.dat gcc-3.4.0-glibc-2.3.2.dat` sh all.sh --notest
 eval `cat arm-softfloat.dat gcc-3.4.1-glibc-2.3.3.dat` sh all.sh --notest
#eval `cat arm-softfloat.dat gcc-3.4.1-glibc-20040827.dat`  sh all.sh --notest

echo Done.

Compiling a simple C program and copying it on the nokia worked fine, so I wrote a simple ObjC test program.. and after copying the libobjc.* files and changing the LD_LIBRARY_PATH to point to a local lib directory, it worked too.

So far, so good !

Now I just need to compile Foundation, then AppKit, then -back ... :-)

Shiny screenshot

2005-11-25T14:09:00.000Z

Well, I spent the evening fixing the ubuntu I broke.. (bad r300 driver, bad..) but then I used the occasion to pass my hoary into a dapper, and in the end (X freezed with it..) to a breezy. And finally everything works fine, _again_ ... pfiew.. (and the synaptic driver decided to work too, yeah). Well, dapper is by definition unstable, so that's my fault. Anyway, I used the occasion to try the composition features of X, and as we apprently lack good screenshots in the GNUstep world, here a shiny one:

Surprisingly with my non-accelerated ati radeon the shadows don't slow particularly the display, so I'm keeping them -- incredible how they add a proper "finished" feeling...

Now I'm just waiting for the next X release (cvs compilation of xorg froze the powerbook) to have this damn ati radeon *accelerated*, because Alex Malmberg GNUstep OpenGL backend is neat (woosh windows disappear in spinning), but.. er... unusable without a 3D acceleration, of course :-/

Structured Edition

2005-11-10T00:20:00.000Z

I have been playing since a week or so with the Text System on Cocoa/GNUstep... it's not immediately easy to understand, but it's really nice and powerful :-)
It handles automatically lots of things, you can redefine many things too (create specific layout manager to change the way the text is displayed, eg, to "flow" around an image, etc.)..

For instance, you're supposed to work with NSTextStorage, which contains the content you're editing, and which is supposedly an attributed string (a string plus related attributes -- fonts, links, attachments, etc), and you edit it via a NSTextView. But what if you want MORE than edit an attributed string ? like, say, edit some structured content ?

Well in fact,the answer is to create a subclass of NSTextStorage that will answer the base methods (just four) of NSTextStorage -- it's in fact a class cluster. So the idea is simply to have on one side your structured document (in my case, a simple array of "Section" objects, containing (optionally) a title and a content), and to have a NSTextStorage that will actually serve as a gateway between the text system (which expect a simple NSAttributedString) and your own structured model... Pretty cool :-) and that way you benefit of all the niceties of the text system..

The above screenshot is my current editor (which btw I wrote under Cocoa, and recompiled this evening on GNUstep), the button is there to define a selected text as a title.

Gorm on Windows

2005-11-04T15:48:00.000Z

Gürkan posted this screenshot of Gorm on Windows :

Ok, the theme used is.. well, the default NeXT theme :-) which doesn't really fit well with the Windows GUI. But still, it's quite cool to have Gorm working on Windows like that :-) (and hopefully once I finish integrating Camaelon -gui modifs somebody will write a Windows theme using the win32 theme api !)

GNUstep/Gorm videos

2005-10-29T18:40:00.000+01:00

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

2005-10-26T20:49:00.000+01:00

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

2005-10-20T16:29:00.000+01:00

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

2005-10-11T00:35:00.000+01:00

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

2005-09-10T19:18:00.000+01:00

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

2005-09-02T21:35:00.000+01:00

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 ?

VERY interesting videos

2005-08-29T23:00:00.000+01:00

Following a link from the Squeak-dev mailing list... I watched theses two videos (a presentation in two parts) by Alan Kay, circa 87 ... They are brilliant, and extremely interesting. Definitely something to view !

Part 1

Part 2

(ps: Squeak is an incredible environment, and Seaside is a fantastic web app framework running in Squeak... worth your time..)

addendum: Interesting PDF about PARC's work ...

addendum 2: another interesting video, an interview of alan kay.

Screenshot UKUUG Demo

2005-08-06T18:16:00.000+01:00

Just to show you how the demo was looking:

Nice no ? :)

UKUUG Talk

2005-08-06T16:35:00.000+01:00

I just gave the UKUUG gnustep presentation an hour ago, and I think it went fine...
Not completely as planned -- I wanted to use keynote on an ibook for the slides part, and use my powerbook under linux to make the demonstration via a vnc connection, and of course... when I tried the setup yesterday it worked without a hitch. But when I tried today just before the presentation the client didn't want to connect for whatever reason .. as I didn't have the time to find what was the problem, I ended doing the keynote presentation with the powerbook (at least it was faster and smoother than if I had used the ibook g3..), and just rebooted under linux for the demo. Not as smooth, but that was ok.

The GNUstep presentation .. -- well, manipulating apps wasn't that easy as the screen wasn't cloned, so I needed to look to the projection screen instead... ;-) but I was able to present mostly all I wanted:

GWorkspace, with Camaelon + the new icons from jasper...

panel hiding, applications hiding, tear-off menus (but all rather quickly though... not sure I explained well that part)

the services system, taking the LaTeX service, the Zipper service and the GNUMail service as example (LaTeX in Ink.app, then use Zipper to create some tgz from GWorkspace, and finally select the tgz and mail it via GNUMail...

GORM -- I started with the basic demo of slider + textview linked together, then I did a demo using a custom palette I wrote yesterday (just for the talk!), which had one object managing a volumetric dataset (a head), and two views rendering the dataset. So it let you create a complete app visualizing a dataset in different way... all in Gorm, without needed to code anything. Pretty nice I thought ;-)

I could have talked much longer than the authorized time, I forgot to say and show some things, but all in all it went well. At the end of the talk the chairman asked how many people had used GNUstep before the talk (3 persons), and how many will try after the talk (5-6 persons?). With around 20+ persons (?) in the room that wasn't bad ;-)

Apparently people were impressed by Gorm :-) , and liked the look of the apps ("it's clean") -- good icons and Camaelon did their job I guess ;-)

I'll put some screenshots later so you could see how did that look..

update...

2005-08-03T21:00:00.000+01:00

Well, quite a lot of things to do this week... in the end I didn't have time to work on camaelon last weekend (well, I worked on the glyph bug) but camaelon 2 release is still planned soon, along with other étoilé's components (hopefully this weekend ? finally ?) .. I need to fix the display glyph bugs in -gui first..

Else, I'm preparing the GNUstep talk I'm giving at the UKUUG 2005 Linux Technical Conference this saturday at the university of swansea, I'll try to make a cool demo of gorm, showing the power of building apps with components .. ;-)

On other topics.. my bag was stolen this afternoon *on my desk*, in the lab, when I went to lunch for half an hour... quite a few things inside, like, my passport, my keys, my newton... that really, really sucks. damn. This in a building supposedly with secured access..

Camaelon's release

2005-07-29T20:23:00.000+01:00

Ok, finally arrived home... quite a lot of things to do next week at the lab, so I'll try if I can to release a public version of Camaelon tomorrow (even if you can already grab it from the étoilé's cvs in Bundles/Camaelon, of course !)

Music

2005-07-26T12:37:00.000+01:00

... One good thing beeing in holiday, you have more time for playing guitar :-)
So I recorded some songs with my cousin, available on boxson.net, a french site that provides hosting, etc., for copyleft music (licence art libre, creative commons...). I think it's great that such initiatives appears beyond the software world...
Anyway. Lots of fun. :-)

Camaelon 2 ?

2005-07-15T00:05:00.000+01:00

I committed a few things on the cvs today and yesterday... here's a screenshot of the current results with the theme Nesedah:

Just grab Camaelon from etoile's cvs, get Nesedah.theme 0.3 and follow the readme :-)

What's missing before an official Camaelon 2.0 release ? well... there's always something missing... for example I'd like to refactorise GSDrawFunctions to use instance methods instead of class methods, so you could change themes on the fly very easily. But I think that can wait for a 2.1 :-)

Appart from that, well, there's a couple of problems apparently with NSMatrix, some wrong text color with cells in general (actually this one is a gnustep bug), and you shouldn't use gnustep to manage the windows with camaelon enabled for now. The menu aren't themed properly (the menu items are, but the menu itself isn't really themed), etc. Nothing very complex overall, so hopefully I'll fix that in the next few days before leaving to France.

Newton...

2005-07-14T14:19:00.000+01:00

Received the wifi card and memory card, so I was able to connect the newton to my local network :-)

After some tweaking, I have NTK (the newton dev environment) running under Classic and connected to the newton using the wifi card :-)

Just started to play with NTK and NewtonScript, but it's quite cool. By far not as cool as IB/Gorm ;-) but NewtonScript is a rather nice language, and NTK seems ok, though not fantastic... got a very basic app running here, where what you write on the newton is displayed on the above textfield when you click on the button (very dull, but it's just to test things ;-)

Not sure what I'll do on it... perhaps a simple calc application where you'd write the numbers / operations and have a "paper trail" ? or perhaps simply a battleship game (there are two already, but they don't use the whole screen, and anyway it's just to play a bit more with NTK/NewtonScript ...). I should also try the xmlrpc lib, it could be cool to use the newton to connect to my visualization system at uni ;-)

I tried VNC on the newton too, both as client and server, and it's extremely cool.. even if it's very slow :-)

Newton & Étoilé

2005-07-09T19:31:00.000+01:00

Well, I didn't do anything last week on gnustep, I just moved from my previous flat to a new one, and in addition to that I also got a newton 2100 from ebay ;-) -- so most of the remaining free time was passed playing with it...

The Newton is really an incredible beast. Ok, it's a bit bulky compared to my pocket pc or my palm Vx... (right, it pass the test of the pocket, but barely, and only because I tried on a huge winter coat with big pockets ;-) -- no chances with a summer coat, that's for sure !) but technically it's a marvel. The writing recognition engine is fantastic: it works! :D
And the UI is great, very well thought, you do everything with the stylus in a logical way (example, to erase a word, just scrible on it... to correct a letter (say, lower case to uppercase) you have a variety of approaches, but the simplest is just to rewrite the letter on the previous one ;-) etc.

The most interesting thing in the UI imho is the "assistant" idea. All datas on the Newton are stored on "soups", kind of databases. Any application can read databases from other apps. So it's easy to really have a synergy between applications. The assistant use that fact: basically, it interprets a sentence (one you just wrote and then pressed the assist icon, or one you wrote directly in the assist window). For example, "remember to buy bread" add the task "buy bread" to the todo list; "meet simon friday" add a new meeting in the calendar application with simon (if you have a simon in your addressbook) on the coming friday, etc. It's truely great. It understand some variations of the formulation (eg, the task "schedule" will be triggered when it encounteers the words "schedule, meet, meet me, talk to, breakfeast, lunch, dinner, holiday, birthday, b-day, bday, anniversary). This mechanism is in fact rather simple, but it works very well !

The writing recognition is excellent (by far the best I ever tried) as I already said; you can choose between 2 engines, one which works letter-by-letter (and works really well) and another that works by words (with attached letters) that works really well too ;-) (this one use neural networks, so it's said to improve -- but I think it already works well :-)

You can also choose to save the writing as "ink text", which let you defer the recognition to a later moment. You can also decide to not have recognition and draw instead; there's two drawing modes, one that "improve" the drawings and a raw drawing. The "improve" drawing means that if you draw something close to, say, a square, it will straighten the lines. Great.

It also can record sound, the use of sound in the UI is quite cool (well, after a while you remove the stylus noises though ;-).

The UI is simple, readable, it handles copy/paste, you got lots of connectivity (fax, email, printing...)...
Basically, they got everything right, or nearly right ! After playing with it, it's really difficult to understand why Apple decided to kill the Newton -- it's so much better than WindowsCE (well, duh..) and PalmOS ! and the best thing... the data is stored persistently, even without power -- no more fear of losing datas when the battery run off. And the batteries are simply 4 AA standard batteries..

The incredible thing is that there's still a lot of people using theses, as well as developers -- I'll try plugging a wifi pcmcia card monday on it, and in theory that should work (got the drivers on a memory card -- two pcmcia ports rulez!); it has web browsers, mail clients, even an mp3 player... not bad for a device made in 1997 ! you just have to wonder what it could have become if apple didn't kill it...

You can program it in Java (there's a waba port) or C/C++, although the normal way to write GUI apps is to use NewtonScript, an interesting dynamic language, object-oriented, based on prototypes.

An interesting page showing you some videos of the Newton: http://www.newtenlightment.de/downloads.html#movies
This one is great too, with a commercial video and its transcript: http://www.aresluna.org/guidebook/extras/videos/welcometonewton

In fact, in many ways, I think NewtonOS is a better OS (UI-wise) than current ones for most of the people, with its emphasis on communication, organisation of personal datas (PIM), and in short, with everything centered around the datas, not the apps.

We should have that kind of orientation in our current computers !! (Actually, Apple made the eMate, which was a NewtonOS device with a keyboard, with a shape a bit similar to the ibook palourde).

So obviously, it gives me a couple of ideas for Étoilé. I think we should deliver a small suite of PIM applications, with shared databases (well, we already wanted to do that to some extent, but what I mean is, we should try to have a way to easily create "open databases" that Étoilé applications would use to save their datas. Such "open" databases would be public (well, limited to the user's app) and easily "discoverable" -- probably a good idea to include their schema/docs in them for example... need to think a bit about that, and I should read in more detail the newton programming book. Yes, our talks about db-enabled fs and this remarks about "open" databases sounds like WinFS, I know ;-) -- but WinFS' goals are actually very interesting.

The other thing is, we should have an assistant-like technology (I sent a mail on the mailing list detailing that point).

A last thing... current PDA/TabletPC UI completeley sucks. Étoilé could perhaps be an excellent choice for a linux-based tabletpc or pda -- as everything already works with only one button (even if it handles more, of course), which is great for such devices, and if we manage to have a good synergy between apps, particularly PIM apps, as well as an assistant technology, that could interest people...

How to make a flash video recording on linux ?

2005-06-30T15:45:00.000+01:00

It's rather easy -- first, you need vnc2swf, and a vnc server.
Start the vnc server on a second X port:

vncserver -geometry 1024x768 :1

Then you can launch vnc2swf:

vnc2swf out.swf :1

That will connect it to the vncserver running on localhost:1, and will output the swf file to out.swf. Start the recording by hitting F9; hitting it again will pause, etc.

Now, to add sound, there isn't a nice way of doing it... but what you can do (and that's what I did) is to launch a sound recorder application in parallel, and start the recording at the same time as the video. At the end of your video recording, you should have the video (out.swf) and a sound file from your recorder app, say "voice.aif". You then need to convert the sound file in mp3 (use the mp3 encoder lame for example).

After that, you just need to add the mp3 to the swf file, and you can do that using edit_vnc2swf :

edit_vnc2swf.py -o final.swf -a voice.mp3 out.swf

The last step is to create a html file containing the following section:


<object width="1024" height="768"
CODEBASE="http://active.macromedia.com/flash5/cabs/swflash.cab#version=5,0,0,0">
<param name="MOVIE" value="final.swf">
<param name="PLAY" value="true">
<param name="LOOP" value="false">
<param name="QUALITY" value="high">
<embed src="final.swf" width="1024" height="768"
 play="true" align="" loop="true" quality="high"
 type="application/x-shockwave-flash"
 pluginspage="http://www.macromedia.com/go/getflashplayer">
</embed>
</object>

Note that you need to set the same dimension as the video, else you'll have artifacts.

And... that's it :-)

STPalette 1.2

2005-06-26T20:48:00.000+01:00

I uploaded STPalette 1.2, you can find it here: http://www.roard.com/gnustep/STPalette-1.2.tgz

The archive contains libStepTalkView, the StepTalkPalette, and CalculatorExample containing the sourcecode and the gorm file of the Calculator done in the flash demo...

Flash Demo !

2005-06-25T17:52:00.000+01:00

I just recorded a flash demo showing how to use Gorm + the StepTalk palette...
the link is http://www.xdev.org/gnustep/demo.html :-)
I'll probably make a release later today, or tomorrow (just to clean up the last things ;-)

Camaelon..

2005-06-24T01:44:00.000+01:00

Just to show a screenshot of the StepTalk palette + StepTalkClass inspector + the calculator with Camaelon enabled :-)
(ok, there's one additional thing though -- the popup to select the return type of the method...)

Shiny, no ?

It works :-)

2005-06-23T19:28:00.000+01:00

After fixing a couple of bugs, I was able to code a simple calculator entirely in Gorm :-)

I need to finish properly the NSMethodSignature encoding, but after that I'll probably make a release.

integration in Gorm..

2005-06-23T12:46:00.000+01:00

I have now a reasonably-working StepTalkClass implementing inheritance -- you can inherits from other StepTalkClass instances or from a normal ObjC class (well, only the methods.. the ivars aren't inherited..). I also started a new inspector in Gorm for managing a StepTalkClass, where you can add ivars and methods, and if you modify a variable in your method the variable correctly changes (eh, useful no ? ;-)

On the other hand, the object model is rather simple -- I don't have classes and instances, I just define ivars and methods. But for a first version that will be enough for most of the needs (you don't really use lots of instances in general for dealing with the UI..), although I think I will implements a class/instance system anyway (I have a StepTalkRuntime that keep tracks of the created classes..)

I have a slight problem at the moment, calling directly a "script method" in a StepTalkClass works, but for some reasons it doesn't in Gorm, so I need to investigate... it's a bit odd as I inform Gorm of the methods, and I can link a button to a method; I implement respondsToSelector: in StepTalkClass, but somehow I don't even get the message... well I'll see that this evening.

I had some problems with NSMethodSignature, by default the StepTalkClass methods returned an object and took only objects as parameters; so it was easy to build the signature (I actually used a convenient method available in STObjCRuntime). But for actions in gorm, the methodsignature must apparently have a void return value.. so I need to allow signature creation with different return values. Setting the signature by hand make it works though, so it won't be difficult. The other problem is that I can't seem to be able to return an int (not an object) from a script method, even if the NSMethodSignature is correct: I end up with a vacall error when I set the return value of the NSInvocation... I need to find a way, else it will be difficult to create for example NSTableView delegates ! :-)

Anyway, I hope that i'll be able to fix the remaining bugs soon and make a release. At least with it you will be able to create for example a calculator completely in Gorm (as in http://www.levenez.com/NeXTSTEP/IB_ex2.html). I think I'll make a flash video to show how it works :-)

StepTalkClass !

2005-06-17T23:55:00.000+01:00

Well, after messing a bit, I have now the following code working:


@implementation Transcript 
+ (void) show: (NSString*) str
{
        NSLog (@"<Transcript> %@", str);
}
@end

...

  StepTalkClass* myClass = [[StepTalkClass alloc] init];

  [myClass setName: @"NewClass"];

  [myClass addIVar: @"Transcript"];
  [myClass setTranscript: [Transcript class]];

  [myClass addMethod: @"display: str" 
        withContent: @"Transcript show: str."];
  [myClass display: @"Hello World!"];

...

<Transcript> Hello World!

...

:-)

Basically, it means I have objects written using StepTalk, integrated in the ObjC runtime. So what it really means is that we'll be able to develop complete applications in StepTalk, directly in Gorm :-)

Well, I still need to do a bit of work -- I need to hook that into the StepTalk palette, and add a reasonably good class browser in Gorm for theses "Steptalk classes", but it shouldn't be to complex.

I will probably have a Smalltalk-like browser, and in the future I'll try to implement some of the ideas described here...

Also, as the metamodel is easily modifiable (obviously :), it's possible to implement interesting things... first, I need to implement single inheritance, categories, class methods, class variables to the current simple model...

StepTalk "objects"

2005-06-17T00:25:00.000+01:00

As I said previously, what I want now is "real" objects in Steptalk, not just scripts. Basically, to abuse the runtime thinking classes really exist as objective-c classes, while in fact they will be a special class containing dictionaries for its ivars and its methods, and that will execute theses methods (mere NSString containing a script) via Steptalk.

It's not done yet... but I have a basic behavior done: I can add a class to the GormClassManager, add a method to it, and connect a button to this virtual method. And that works -- clicking one button connected to the standard execute: method does something, clicking on a second button connected to the virtual method does something else :-)

So, well, it's not ready yet, but things looks good :-)

STPalette 1.1

2005-06-15T21:48:00.000+01:00

I worked a bit on the steptalk palette today, and I added some nice improvements...

You can create script outlets on the fly -- no need to use the object1,object2,...object9 limitation.. :-)

I added a non-ui object that you can instanciate as any object

The StepTalkView is still there, but more like a button containing a script. And actually by default its target/action is itself, so when you click on it, you execute the script. To change the default image, just dragn'drop another on it :-)

added a connection inspector to only show the script outlets

So basically now, it's more useable imho :-) and starts to be quite nice.

Check the readme files for more infos. You can download it from here: http://www.roard.com/gnustep/STPalette-1.1.tgz

enjoy :)

StepTalk Palette 1.0 released :-)

2005-06-15T00:30:00.000+01:00

Well, I had the time this evening to create a small libStepTalkView library (containing... the StepTalkView widget...) and correct a few things, so I thought it was good enough for a release ! For once I'm trying to do "release early, release often". Although I'm not sure about the latter... ;-)

Anyway, the whole package (libStepTalkView and StepTalkPalette) is here: http://www.roard.com/gnustep/STPalette-1.0.tgz

What's wrong at the moment ? well, it seems the StepTalkView class is not properly exported somehow, so you need to reload manually the class in Gorm (Classes->load class, load StepTalkView.h from libStepTalkView) before drag'n dropping a StepTalkView -- I guess that's probably easy to fix. Else it seems to work..

What I'd like to do now is to create outlets/actions on the fly (well, actually, tell Gorm about them) -- if I can do that, then I can create an object that will let you dynamically create "StepTalk objects" -- add instance variables, methods, etc. Each "methods" will contains a script, executed on the fly, and each instance variables will be passed to the scripts. Not completely sure about methods parameters, but I'll probably find a nice way to deal with them...

Anyway, if I can do that (and that seem doable..), then you could really program entirely in Gorm :-)

(although it probably won't be very fast, for sure... but for prototyping that would be quite useful I think, and if you need perfs, you can create an ObjC object!).

Have fun, and contact me if you have ideas :-)

Steptalk palette :-)

2005-06-14T00:27:00.000+01:00

Making a StepTalk palette was quite simple, as it turned out...

Now I just need to build a proper framework and add a non-view StepTalk object in addition to the current one... :-)

Steptalk integration ..

2005-06-13T16:33:00.000+01:00

Now that I have something mostly working on the "stack" side .. what would be neat is to have a way of adding some little code snippets directly in Gorm and link them to actions; it's not meant to replace ObjC coding, but in my "hypercard"-like idea, it's ok -- you'll use small scripts to do some of the things, and if you want really complex stuff you can use objc objects. Well I guess people could abuse the script system, but hey..

So, the obvious way to add scripting is to use Steptalk, Stefan Urbanek's script engine for GNUstep. Furthermore, Steptalk isn't tied to a specific language (actually it can support a smalltalk-like language and scheme, and we could have something else like ruby in the future...).

I had a look to F-Script but I was disappointed by its IB palette.. basically it's not really useable for what I want ;-) -- even if I didn't want to use it, I was wondering how the palette was working, as I thought it permitted what I want... in fact, it kinda does, but by setting manually the targets/actions of objects in the script .. bah :-) -- I want something more easy to use.

Well, I compiled Steptalk on OSX to play a bit with it, and I'm trying to think about how the palette could work to provide an environment as easy to use as possible... F-Script palette's idea of defining a bunch of outlets (object1, object2, .. object9) on the F-Script view where you link objects to have them accessible from the script is a bit crude, but for a start it will do the work. Though I think it should be possible to create a custom editor/connector that will let you add outlets on the fly, which would be a better way. Need to ask greg about that :-)

So the idea is to create a Steptalk palette that will contain a "Steptalk object" (which will contains a steptalk environment and
a text containing the script). You will be able to connect outlets to this object (and theses outlets will then be accessible from the script), and also use it as a target (so you could connect a button to it, when the button is clicked it will execute the content of the script). That won't be a perfect system and not as transparent as visual basic / hypercard (eg, click on the button, you get a window with the corresponding code executed onClick), but that would be a start. This "Steptalk object" won't be a view, but we could have a simple view so you could put the script on your windows (this view won't show when the program is running...).

Something that could be interesting too is to use custom widgets that already contains a steptalk object, with their target/action set to it. For example, the Stack could (and probably should) contains such an object. Same for the cards. And we could have a custom button containing a steptalk object too, which will then permit the "I click on the button and the code appears" scenario...

update on the hypercard idea...

2005-06-12T21:23:00.000+01:00

Well, after backuping OSX, then formatting my hard drive, then reinstalling the backup image on it.. I was able to easily install ubuntu on my powerbook, and now I've got a working gnustep env :-)
Ok, no touchpad support, no wifi support (damn you broadcom !), no luminous keyboard support... but it works :-)

So I was able to start recoding a palette for Gorm.. with a bit of help from gregory casamento, it now works :-)
Well, sort of. It's not persistent in "test mode" yet. And I need to finish my IB Editor subclass to support the Card connections (eg, connect something to the Card, not just to the Stack object). So what's working ? Well:

There's a palette containing a Stack object -- you can drag'n drop it on you window

The Stack object contains one Card by default, and you can drag'n drop things on it (buttons, textfields...)

There's a Stack inspector, so you can add new cards, and navigate through the existing cards

There's also the possibility of creating a card from an existing one (eg, the second card will be a copy), which I need to implement the "background elements" thing, useful in the database case

So what needs to be done ? Well, as said before, add connection support to the Card view (so you could for example add a button that when clicked go directly to the card); then add persistency to the cards (I will probably just encode them for a first try... perhaps in the future something with CoreData (if we have a clone ..) or GDL2 ? or a custom solution ? but who knows, simply using encoding will perhaps be good enough for the use I expect, eg, very small databases...)

So anyway, good progresses... and now I have a much better idea about palettes ;-) so i'll probably do some more -- for example, a palette containing NSArray/NSDictionary could be rather useful, particularly if they have an editor to let you add data, and particularly in my "hypercard"-like scenario.. then, I'll just need a Steptalk palette ! :-D

Hypercard and Gorm ?

2005-06-11T00:10:00.000+01:00

Hypercard ? Never used it, but always heard good things about it.. (starting from Dave Small's articles ;-)
So in another round of web procrastination, I tried to find more infos about it. Turns out it was quite interesting, and modern incarnations such as Revolution are quite cool too.

So what's cool with Hypercard ?

You could say that it was one of the first easy to use "gui builder" -- you just drag'n drop elements on your screen, click on them to open a script function that will be triggered (for example when the user click on the element), etc. And it's not limited to widgets, you can draw, add images, sound... More than a gui builder, Hypercard was the first multimedia authoring system..

You program it using Hypertalk, a "natural" programming language (ie, close to english, rather lax). Interesting.

The real interesting bit: everything revolves around the concept of Stacks of Cards. Basically, you start with a stack containing one card. You can have more than one card in a stack (duh), and only one card is displayed at a time. So, a card is a "screen" if you want. And then you have the possibility to navigate through the cards, going from one card to another, to add cards, etc. Which is basically a hypertext (or hypermedia in that case) system. Now, the other great thing is that cards are persistants : if you add something to a card, it will stay. If you quit hypercard, restart it, reload your stack, what you added on the card is still there. Combine that with the ability to specify some of the elements on a card as "background elements" (meaning they'll be there on any cards of the stack) and you have a really simple method to define databases. Which is why Hypercard was also considered as a database. Pfew, quite a lot of possibilites, no wonder Apple's management had a hard time figuring it out ;-)

An example of creating a database: Just create a new card, add some textfields... add buttons to navigate (prev card, next card) and a button to add / remove a card. Set the textfields as background elements. And voila ! you're done ! Now you can run your stack, fill in the card, and when you need to add a new card, just click on the button. Great no ? In addition Hypercard could easily search through a stack, so it wasn't difficult to add search possibilities too.. And if you need to add a new information ? just add a new textfield :-)

So to sum up, quite a neat system. As I never used it, I perhaps misunderstood some of the possibilites, but playing a bit with Revolution, I'm not too far from what I describe..

I now understand more why lots of people liked it -- it was really a great system for "non programmers" to actually do great things with their computer. It's a shame Apple didn't push it more...

Anyway... I needed to explain all that to introduce my idea : Gorm is the InterfaceBuilder-like program for the GNUstep framework. You could say it's just another "gui builder" ... and you would be rather wrong ! Because instead of limiting itself to describe UI elements layout.. it really only deals with objects. Live objects. Which means you can even try your user interface, link buttons to actions, etc., all without compiling. And it's any objects -- not just graphical objects.

When you set options of the elements on your UI, you really work on the objects themselves. Then the UI is saved -- in fact, the objects graph is simply serialized in a file. When your GNUstep (or Cocoa) program starts, it just load this serialized graph of objects back in memory. That's the great thing with InterfaceBuilder and Gorm : you can set up a lot of things directly, without writing a line of code. The other good thing is you can define your own palettes of objects :-) so at the end, you can build complex program simply by drag'n drop... well, that's the idea anyway. Recent Apple's additions to the Cocoa API goes toward that (NSController, CoreData...).

So what's my idea then ? Well, it occured to me that you could simply have two objects -- a "Card" object and a "Stack" object, and put them on a Gorm (or IB) palette. The "Card" object will accept other objects (textfields, images...) and will also be in charge of saving their state. So there you'd have a persistant Card. The "Stack" object will maintain a collection of Cards, and will answer to messages like "go to card #2", "go to next card", or "create a new card".

Thoses two objects will provide you with Hypercard-like functionalities -- just start Gorm, select the "hypercard" palette, drag'n drop a Stack view on your window, and then add what you want on it. Want another card, open the Stack inspector and add one. Add new objects on it. Add some buttons on your window, and link the buttons' actions to some methods of the Stack or of the current card. And of course, instead of widgets, you could drop images or sound ... why not ?

Now, imagine we'd have a Steptalk palette to create scripts objects... and voila, you have an hypertalk-like system :-) -- all that inside Gorm (or InterfaceBuilder), leveraging the Gorm's UI builder possibilities. Imagine now we add a few nice graphical transitions or other niceties... and you end up with a rather good multimedia authoring system that generates binaries :-)
-- and if you want to add your own objects to it, to extend it.. well, it's still Gorm and GNUstep, so you can easily do that, obviously :-)

Ok, that was a long post... :-)

So in short, the idea sounds quite cool to me, and I actually started to implement a palette with thoses two objects on InterfaceBuilder (MacOSX). Sadly, palette creation isn't that well documented and I ran into a couple of strange problems .. so ... I'll do that with Gorm first, it'll be easier. Didn't start with Gorm for a very simple reason -- since Tiger, my GNUstep/OSX installation is b0rked. In the end, I'm installing a linux distrib (ubuntu PPC) ... Should be easier to have a working GNUstep environment ! :D

First Post...

2005-06-11T00:00:00.000+01:00

Well, I finally decided myself to open a blog. What for ? hm.. mainly to record my thoughts and ideas about computer science, programming, etc. I'm not really into writing personal stuff about me :-)

At least it will give me with a known place where I can write things and find them later...

Just the bare minimum about myself: I'm 26, french, in the middle of my PhD. I live in Wales, UK. Crap weather, but nice place and nice people.

I'm involved with some free software projects, mainly GNUstep and Étoilé. Which is why I'm writing in english rather than in french, as many of the things I plan to write here will likely concern thoses projects.

We'll see how it turns out !