Random thoughts of a Camaelon

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.

Publié par Nicolas à Thursday, March 27, 2008 2 commentaires

Libellés : cool, geek, gnustep, google, programming, summer of code

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 !

Publié par Nicolas à Sunday, September 09, 2007 0 commentaires

Libellés : étoilé, gnustep

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)

Publié par Nicolas à Tuesday, September 04, 2007 3 commentaires

Libellés : cool, étoilé, gnustep, screenshots

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.

Publié par Nicolas à Tuesday, September 04, 2007 0 commentaires

Libellés : cool, étoilé, gnustep, screenshots

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...)

Publié par Nicolas à Sunday, September 02, 2007 2 commentaires

Libellés : étoilé, geek, gnustep, hack, photo, screenshots

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.

Publié par Nicolas à Sunday, September 02, 2007 5 commentaires

Libellés : cool, étoilé, gnustep, hack

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).

Publié par Nicolas à Saturday, March 24, 2007 1 commentaires

Libellés : geek, gnustep, NeXT, smalltalk

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...

Publié par Nicolas à Friday, March 16, 2007 1 commentaires

Libellés : étoilé, gnustep, google, summer of code

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);
}

Publié par Nicolas à Friday, January 19, 2007 2 commentaires

Libellés : gnustep, hack, objective-c

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 ?

Publié par Nicolas à Monday, December 04, 2006 1 commentaires

Libellés : cocoa, gnustep, objective-c, screenshots, steptalk

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.. :-)

Publié par Nicolas à Thursday, May 11, 2006 1 commentaires

Libellés : étoilé, gnustep, screenshots

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...

Publié par Nicolas à Wednesday, May 03, 2006 2 commentaires

Libellés : étoilé, gnustep

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...

Publié par Nicolas à Sunday, March 05, 2006 0 commentaires

Libellés : demo, fosdem, gnustep, talk

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).

Publié par Nicolas à Thursday, January 26, 2006 2 commentaires

Libellés : gnustep, hack, nokia 770

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 :-/

Publié par Nicolas à Friday, November 25, 2005 3 commentaires

Libellés : étoilé, gnustep, screenshots

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.

Publié par Nicolas à Thursday, November 10, 2005 3 commentaires

Libellés : cocoa, étoilé, gnustep, hack, screenshots

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 !)

Publié par Nicolas à Friday, November 04, 2005 2 commentaires

Libellés : gnustep, screenshots

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 !

Publié par Nicolas à Saturday, October 29, 2005 6 commentaires

Libellés : gnustep

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.

Publié par Nicolas à Thursday, October 20, 2005 7 commentaires

Libellés : cool, dynabook, étoilé, geek, gnustep, nokia 770, rant

Just to show you how the demo was looking:



Nice no ? :)

Publié par Nicolas à Saturday, August 06, 2005 6 commentaires

Libellés : gnustep, screenshots, talk, ukuug