KIS Technoblog

So, Intel and Nokia and the Trolls at Qt have linked up and are merging Maemo with Moblin to create something called MeeGo

(I think I’ve got the caps in the right places…)

As this is a a potential target development environment (and especially since the development platform of choice is Qt), I’ve been very interested in checking it out, once it got to a fairly stable state. Now, the first ‘unified’ environment is available and I can take it out for a spin.

Installation

An installation is a two-phased job for me: the environment, itself, and the development SDK. First the SDK:

This has to be done on a Linux Box, because it’s a whole ‘chroot’ environment. If you don’t know what that is, think FreeBSD ‘jails’. If you don’t know what that is, think kind of like virtual machine, but not really. It’s just an isolated filesystem that looks like a whole different machine, inside of another machine. You log into it, and from there on, it appears to your login process that you’re on that machine.

I installed the chroot image on an Ubuntu 10.04 (latest) Fusion VM on a Macbook, which gave me a ‘kind-of’ VM inside of a VM configuration. It could drive you crazy, thinking about it – but the bottom line is: it works. Including the emulator. The only issue I had was that video wasn’t visible. But, I did have a Meego desktop to play with, and the SDK appears to be available.

The SDK is a kind of typical remote cross-platform development environment, except it’s not really needed, for the netbook app – the target is just another x86 linux implementation. In fact, I wonder if you couldn’t just put the SDK on the netbook, compile there, and then debug remotely.

There are probably performance issues, there – especially if the builds got big – but you do wonder…

On to the Hardware – ASUS 1000H (dual boot w/ easy-peasy image)

The initial task over, it was time to put the OS on some real hardware. I have an ASUS 1000H, dedicated to just such endeavors. It has easy-peasy in the first partition, but I left some space in a blank partition and can dual-boot through GRUB.

This turned out to be a little tricky – the installation process wouldn’t let me install without a boot sector, and it wanted to use a different file system called btrfs. For some reason, the installation didn’t like that in a non-default partition and complained that a btrfs system is unbootable. So, I had to fallback to ext3 (ext4 was not an available choice.) It hung when trying to load the boot sector (which I suspect boots into something non-btrfs, so I killed it, booted back into the easy-peasy image, and did a ‘grub-update’. Handy – the new grub 2 scans the disks for likely OS candidates and presents them in the boot menu.

Voila! Boot into Meego and everything looks fine.

The Verdict

Well, it is cute!!

Those little brightly-colored blocky people populating the intro video and all of the promotion materials look real friendly, and they look happy, too! How bad can it be?

When you hover over a menu item, it squoidges (my own term – I don’t know what else to call it – basically a ‘bounce’ animation done in scale-factor.) Run your mouse along the menu bar, and you get squoidge, squoidge, squoidge… as the mouse passes over the menu.

In terms of layout, it kind of follows the Ubuntu UNR/easy-peasy form – a bar at the top to select various ‘panels’, which are fixed size and take up the whole screen, although each panel may be divided into subpanels.

Beyond that, it’s more like a cell-phone OS. You have an applications panel – that seems normal. And you can select applications, launch them, and add them to a favorites panel. That seems normal, too (in fact, most of the applications are generic Linux apps, that look and feel like generic Linux apps.

It’s very heavy on the ’social’ and ‘personal’ aspects. Everything is geared towards showing all your friends, allowing your friends to ping you or you to ping them, your mail and calendar are right up front.

What is different is that things you’d normally expect to see in a web browser – facebook contacts, calendar updates, blogs, etc., can show up directly on a panel. The idea, presumably, is that getting to those would be quicker directly from a panel, rather than having to bring up a web-browser and navigate to a page – something that can be onerous and time-consuming on a small device.

No Login

Again, reflecting the device-OS ancestry of Maemo – there is no capability for multiple user accounts. it’s really tuned to reside on a personal device. So personal, you don’t have to log in. The upside is that when it comes up, it’s ready to go. The downside is that if someone else is using the netbook, they’ll likely screw up the desktop (or view that you have screwed up the desktop.) Not only that, but with it’s heavy emphasis on ’social’ apps, it’s like someone else logged into your Facebook app. All of your personal details are there.

I’d have to concur with others who have installed it on hardware – it’s really fast. It looks like this is a really trimmed down Linux distro. A lot of heavy stuff that used to happen at boot time is apparently deferred, or eliminated, already, because it’s not something that is needed on a device OS.

So, it boots fast, it runs fast.

Is it usable?

My initial impression (thus far) is that it would be a really good tablet OS (or, of course, a cellphone/pda OS), rather than a netbook OS. I don’t think I’m going to give up the easy-peasy environment on this netbook, just yet. For one thing, my netbook serves as a ‘kitchen’ pc, with different accounts so my Significant Other can log in and mess up the screen layout anyway she wants…

In the tablet/OS environment, text input is always the issue. Nothing has beat the keyboard, yet, but smaller devices can’t handle them. So, there have been a variety of solutions – virtual keyboards, character stroke recognizers, full handwriting recognizers, and the occasional oddball scheme designed for eye-tracking (which can work quite well, but it is an odd way of expressing things) – all of these have have their trade-offs and none have been proven to be faster or more accurate than the good old keyboard.

Of course, this is version 1.0 and there is a whole lot yet to be done. It’s definitely a different paradigm, I think, one that’s going to take a bit of getting used to. It seems more natural to smaller devices without a keyboard, but I think that is the real intended direction. Having it as a netbook OS is just icing.

I’m getting ready to open-source QXSAP (a Qt-based multi-lingual and simple marshaling parser) and, of course, before doing that, I need to get it into a source control repository, of some sort.

In the past, that’s been SCCS (Source Code Control System), RCS (Revision Control System), CVS (Concurrent Versioning System) and finally SVN (Subversion), with a couple of side trips to some strange source control systems, whose names I forget and would rather not recall.

Something New: Git

Now, the latest thing is Git, created by no less a luminary than Linus Torvald, himself. I’m not sure if the name is an acronym that stands for something, or if it’s just a play on the slang term to ‘git’ something. Whatever – it’s the VCS du jour, and it’s being used by a lot of important (to me) organizations, primarily Nokia for Qt and all it’s sub-components.

Gitorious is the repository of choice for Qt-based objects, so that’s where I want to put QXSAP.

Which means I’ve had to spend the last couple of days getting up to speed on Git. From what I’ve seen, it looks like it’s capable of doing anything it’s predecessors can do. I like the idea of having a local repository, and that the repositories can communicate with each other and update themselves. Beyond the standard required features (fetch/push/branch/tag, etc), the ’stash’ mechanism seems kind of interesting.

Start out with the basics, and then broaden the scope, from there.

Until the next ‘new best thing’ comes along….

The Symbian development platform (on which I’m currently working) has historically been incredibly arcane. A modified C++ with a non-standard exception mechanism, for starters. And a whole bunch of pieces to install, one of which is a doctored up Eclipse IDE.

Qt doesn’t alleviate the proliferation of installation pieces, at the moment, primarily because everything is still in transition. In fact, you have to install a whole bunch more new pieces to get the development environment together on your desktop machine and on the phone.

QtCreator

One of those available new pieces is QtCreator, Qt’s answer to the IDE.

I’ve used a lot of IDE’s over my career, and they all have their pluses and minuses. MSDEV is great for MS-only applications (and is particularly brilliant in C#). XCode is cool on the Mac, and Eclipse is great for Java. I’ve been a fan of Eclipse since working with it on a Java project a couple of years ago, and so was looking forward to using it in the Symbian environment – since Carbide C++ (the blessed Symbian IDE) is based on it.

That proved to be somewhat less than productive – the environment is insanely fragile. I managed to break the debug perspective completely, just trying to move a few windows around (the Variables window, specifically). It took some research and digging down into the nest of hidden project files to find the proper configuration file to delete and get some order back to the IDE. Then, too, communicating with the phone required yet another panel with arcane settings, and that had to be reset, frequently.

Since I’m using Qt, I thought it would be an interesting exercise to use Qt’s blessed IDE, even thought it’s still at an early stage of development.

Order of Magnitude

I can honestly say, QtCreator has been a lifesaver for this project. For starters, though still in early incarnation, it’s really good and intuitive to use for Qt development. And, it seems to communicate with the phone more readily.

There are a lot of glitches, still – I have yet to get the on-device debugger to work. Judicious use of qDebug() statements have been the stop-gap measure around that – effectively reducing debugging to the proverbial ‘print statement’ technique. Not optimal, but it works. And I can’t get the debugger to work on the device in Carbide-C++, either, so it’s no effective difference, there.

Better than nothing.

But, what has been the real lifesaver has been the ability to take advantage of an outfall of what Qt ultimately is: a cross-platform development environment. What this means in practical terms is this: you can do a lot of development on the desktop!

When you install Qt, you can install two versions – one for the desktop, and one for the phone. QtCreator has a (admittedly wanky, but slated for improvement) configuration panel that allows you to switch between build configurations: desktop or device (actually, there are two configurations for the device, as well – emulator vs. actual device.) You have to flip a bunch of switches to do it, but I’ve gotten it down to a fairly manageable routine and can flip between the two environments with relative ease.

That ability has been nothing but a godsend (or maybe a troll-send) for this project of limited funding and limited timeframe. Turnaround (the time it takes to go through a code, run, debug, fix and do it again cycle) on the device is slow. Turnaround in the emulator is even slower. But turnaround on the desktop is fast – no loading required.

Because of that, I’ve been able to do a large bulk of the coding effort – getting the big stuff in place – on the desktop. It helps to create an appropriately sized main window, and you do have to have a jumparound here and there (primarily for the OpenGLES stuff and the menu system), but most of the code and components are exactly the same.

So, when it comes time to deploy to the device, most of the hard stuff has been done. Now you can focus on the harder, device-specific stuff.

Not the Same

Just to come full circle, QtCreator has some real promise. It has glitches – the VIM emulator is a great idea, but I’m seeing a bunch of issues with it. I’m told that much of this is fixed in the newer version.

It’s difficult to specify and organize source folders – I’ve taken to creating source file ‘hulls’ on the command-line in the directories I want them, and then update the .pro file, accordingly. The IDE will honor what you’ve created, and show appropriate folder organization.

Not on the Mac, though – the project contents are just a flat list of entries. You can still get to stuff, but you may have to scroll through a long list of other stuff to get to it. I imagine that will get fixed in the next update or two as well.

Summary

Overall, I think this will only get better. The Trolls (now part of Nokia) are working on this furiously (note the announcement of Meego and the parallel announcement that Qt will be the development platform of choice on that environment – it already is on Maemo).

For me, QtCreator will definitely become the development platform of choice for future Qt applications, with decreasing reliance on the platform-specific IDE.

Yet a new platform to exercise my Qt chops on.

As you may or may not know, Qt has been acquired by Nokia. It appears that Qt will be the development environment of choice for all of Nokia current and future OS’s, including Symbian, Maemo, and the newly announced Meego.

And that’s a good thing.

Leveraging Qt

I can speak for a newbie getting into the Symbian S60 environment: If it weren’t for Qt, this would have been a much more difficult endeavor.

As it was, I was able to put together a pretty sophisticated molecular modeling app, complete with 3D OpenGLES visualization, in about six weeks, thus far. (Still putting in HTML downloads and cleaning up interaction.)

It’s not without issues. The Trolls and Nokia are still getting to grok one another. So some things (like the menu system) display some strange behavior, and Qt doesn’t support OpenGLES on Symbian, yet (at least not on the S60 devices.) So, I’ve had to ‘go native’ for the OpenGL. Not the end of the world – it just means opening up a Native Symbian window and creating a QObject-based class to serve as a controller. It’s working fine.

Trying to do this in native Symbian would have likely at least doubled the development time, I think. By leveraging the Qt knowledge already gained, the process of moving to a new platform like Symbian is greatly facilitated.

Now, if we could just get Qt on the iPhone and Android (efforts are underway for these – see here and here.)

It’s occurred to me that, having worked in a number of languages and platforms, lately, just how much an influence Qt has been, particularly the signal-slot mechanism.

That single mechanism is, in my mind, as much an innovative development as the subroutine, the library, and the class.

Why so?

Fundamentally, because it provides a mechanism for incredibly strong isolation of modules, which, in turn, makes them more likely candidates for re-use. It also allows for stronger modular development in general – you can focus tightly on the functionality of the module and – perhaps even more importantl – you can hook tests to the module with ease. Unit testing is an easy and natural fallout of signals and slots.

IT’S WHAT I HAVE coined as ‘connection-based architecture’. (In ‘pattern-speak’, it’s called the observer pattern.)

Whatever you want to call it, it’s the best thing since sliced bread.

Once you’re exposed to it and have to go over to another language or toolkit, you immediately look for an equivalent mechanism in that technology. Some toolkits/languages provide the function inherently, others somewhat. For instance, Objective C implements it as part of the language construct. In fact, you could look at Objective C and wonder if Trolltech didn’t use it as a model – in effect turning C++ into an Objective C implementation. The syntax of Objective C for sending messages is a bit funky, but the functionality permeates every class declared in the language, which is better than Qt can do – you have to derive from QObject or embed a QObject-based instance to use it in C++.

The .NET CLR languages have a corollary in their delegate mechanism (not to be confused with Qt’s ‘delegate’ base class). Essentially, you can declare a delegate as a singular notification mechanism that behaves very much as a signaler, and you can register classes to receive it’s signals on a function. Syntax variants to declare and use delegates vary from language to language. In VB, it’s terrible (unless changed recently.) In C# (really the only language to write .NET apps in, IMHO), it’s easy.

As you go down the language line, it becomes increasingly difficult to use this kind of mechanism. ECMA-based scripting languages (ActionScript3, JavaScript), for instance, don’t have quite an equivalent mechanism, but the event mechanism is closely analogous. It’s reasonably easy to create a custom event and provide handlers for the event.

Server side languages are harder. Java actually has an Observer class, but it’s kind of clunky to use and not typesafe. Perhaps with the emergence of the generics construct, it may be easier to implement a signal-slot type of mechanism.

Of course, signals and slots are not the only thing that makes Qt a standout technology – the window and widget abstraction are often the rationale for using Qt in the first place. If you’ve ever tried to create a multi-platform application from scratch (I have – pre-Qt), it’s a lot of work and you’re often restricted to lowest-common-denominator functionality.

And, Qt provides some other niceties, as well – the bundled 3rd party functionality for things like XML handling relieves you from having to build and support these things as extras (which can be a difficult endeavor in a multiple-platform effort.)

But, the real conceptual leap (unless you’ve been a NEXT/Mac developer working in Objective C) is the signal-slot mechanism. The rest is UI abstraction, a certain amount of architectural framing (which is useful), and bundling.

That dynamic connection-based isolation capability is what I look for any time I have to make a move.

It should come as no surprise that ActionScript3 (Flex/Flash) are second class citizens in the Facebook app world.

But, that doesn’t make it any less frustrating, when you encounter it.

The most recent turn appears to involve the app installing itself into the users account. This used to work swimmingly well. Now, all of a sudden, I’m discovering my potential users can’t install. They never get the ‘Allow’ dialog and the app just hangs on connection.

Various tests show that all of my Flex/Flash, apps and test platforms do this, so it’s not just the app in question. The PHP tests, of course, work swimmingly well.

Other AS3 app developers have noticed this, too, and have had to implement a range of workarounds to fix it. I think FB has screwed up their permissions files for AS3. It would be nice to get FB’s attention to figure out what went wrong, or Adobe’s, but that’s like trying to get through to MS. All you can do is spatter messages on the boards and pray.

So, I’m in the middle of figuring out how to do the workarounds and still stay in the AS3 codespace. Another alternative is to let PHP set up the session and then the Flex app can just attach itself to that session.

Of course, once I get this many-days-endeavor implemented, FB will fix it, and everything will work properly as it did before, in the original context.

But, should they mess up again, the workaround will be a good failsafe against that.

Grouse, grouse. Ommm, Ommm.

Well, I’ve upgraded my FreeBSD server and everything is back in order, including a new version of WordPress.

And, I’ve reinstated the comments mechanism (restored the DB table) and installed the reCaptcha mechanism. So far, so good – spam appears to be throttled, but not completely eliminated.

At least it’s manageable.

On AJAX

I’m kind of mystified why so many sites haven’t incorporated AJAX – a lot of really big sites still do a full page refresh when something is updated. I can’t attribute it to ignorance, so it must be … dare I say … laziness?

Some notes on my approach to AJAX:

1. A lot of the AJAX libraries descend into baroque-ness, normally pointed toward updating parts of the page with HTML snippets. The MS implementation seems to be the worst offender. This seems like a bad idea, to me.
2. To maintain presentation/logic separation we like so much in architecture circles, you don’t want to be passing UI stuff over the wire – the only possible exception is if you’re creating all of your UI on the wire (which strikes me as prime fodder for loading up the server, so I don’t like to do that, anyway…)
3. JSON is the lingua-franca of AJAX, not HTML. Better to pass JSON-encoded data back and forth and let the server and the client handle their ends appropriately. I’m a big fan of off-loading as much as possible to the client, anyway. Stuff like forms validation should be done – at least preliminarily – at the client. The client should re-arrange itself based on JSON responses and data.
4. You never know what the next new big thing is. You’re client might be written in JS, now, but tomorrow’s need may likely be Flash, Silverlight, or who knows what? Passing back and forth snippets of JSON and keeping the semantics simple doesn’t break the back-end, or entail hoops trying to support multiple types of clients.
5. There’s nothing better than updating just part of a page. Full page refreshes are jarring.

I’m sure there are exceptions (there always are), but that’s the way things appear to this author, as of this writing.

… and with our coding dead… (with apologies to Shakespeare).

Again, I haven’t been keeping this up.. why? Spam is driving me crazy. I’m currently upgrading the server and will put in a captcha to re-implement comments. After all, what’s a blog without feedback?

Adobe Flex/Flash

On the development side, I haven’t been dormant: I’ve been investigating the new Flash and Flex technologies from Adobe.

Since Adobe took over Flash from Macromedia, there has been an all out push to turn the Flash technology into a bona-fide development environment. That makes it a candidate for investigation (especially to one who professes to be a graphics developer.)

The outcome? You can see one outcome on Facebook (this is also an exercise in exploring the ’social media’ platform): Active Biorhythm. It’s pretty cute – if you’re a Facebook user, you should be able to fire it right up (you might need to log in, first.) The first tab shows your six most compatible friends for varying attributes with a series of (active, of course) venn diagrams. The second tab shows your personal values with (active, again) bar-charts. (The ‘in-tip’ value labels is a nice touch…)

The third tab is the most interesting in terms of potential applications, IMHO: Think ‘Google Analytics’ type charting, with active information popups at appropriate places. As you hover over a curve, for instance, the other curves fade into the background and data at that point is reflected in an ‘info balloon’, which has a connector to the table readout value below, for good measure.

The current date can be changed by grabbing the red cursor and dragging it, or by hovering over the pointers on the sides of the graph. A friend can be loaded, either from the compatibility panel or from the name panel on top, and the chart will show comparison values, as well as a drop-down ‘compatibility panel’ for all attributes.

It’s an interesting demo of how to show a lot of information on a graph, without cluttering it up with legends, etc. I’m sure a graphics designer (which I don’t profess to be) could think of some very interesting possibilities. It needs a bit of work, still, but it’s quite functional.

The next exploration in this (Flash/Flex) technology will be a 3d library which has been built on top of Flash, talking directly to the GPU . From what I’ve seen, it looks very promising.

Aside: ActionScript3 is ok – it’s an ECMA-derived script, so there are a lot of familiarities. The only thing I don’t like is the kind of backward typing statements (typing, in and of itself is good, of course).

For instance, to declare a variable of type ‘String’ looks like thus:


var myVar:String;

Nothing wrong with that, but say this is local to a function and you want to promote it to class scope. What you need to do is remove the ‘var’ and the ‘:String’ so the lvalue in the assignment doesn’t have the type/instance declarations – that’s a two select-and-click process (other languages the type/instance declarations precede the variable name – one select-and-click to remove.)

No biggee, just a little bit of a nuisance.

Working with the FlexBuilder development environment is much better than working in the Flash Authoring Tool. The latter doesn’t help you very much — FlexBuilder is Eclipse, so it helps a lot (although not as much as it does with Java.) The only issue is that it produces large .SWF files, compared to those created with the FAT.

So, onward. I’ll be working the rest of the day putting in a ‘captcha’ and updating the wp software so comments can be left.

You will be free to add illuminating remarks when that’s done.

… but no spam!!…

I haven’t written in this for quite a while.  With all the spam I’ve been getting on this, it’s been discouraging to do much more writing.  I’ve currently disabled feedback – will re-enable when I get the chance.

At any rate, I’ve been up to my ears in alligators, learning new technologies (same old story), reinforcing what I know in old technologies (same old story, but new twists), and meeting deadlines.

So, I haven’t had much time to ruminate.

Where I’ve Been

Java, for one – and JOGL: This falls under the category of ’same old story, new twists’, leveraging my architecting application design experience into the land of Java, and the OpenGL/3DGraphics expertise into JOGL (Java OpenGL).

It’s worked out very nicely – Java is, of course, another ‘C’ language derivative with a bit of an emphasis on threading, especially for the UI aspects. The Eclipse developer framework is a joy to use, and I’m happy to see it becoming increasingly available for a number of languages and platforms.

JOGL is a reasonable performer, although with large models, we could see it bogging down. It would have been an interesting exercise to have loaded the same models (protein molecules, in this case) in a C++ based system to benchmark performance on some of the larger molecules. It would also have been a worthwhile exercise to isolate the graphics and try one of the newer scenegraph-based technologies (Xith, OpenSceneGraph, etc.) to try to move to higher level constructs, rather than raw OpenGL. Unfortunately, the funding ran out before any of that could be undertaken.

But, the re-architecting and bugfixing were very successful. Here’s one place the results can be seen (Java WebStart App – I’ve been seeing stalled downloads from overseas, unfortunately. Hit ESC to exit):pdb.org Kiosk Viewer

Where I’m at, Now

Flash and ActionScript have always been on the periphery. I’ve decided to take out some time and investigate these technologies, more thoroughly, with a couple of FaceBook apps as the projected end-result. A couple of observations:

• AS3 is essentially an ECMA-based language. As such, it shares a lot with JavaScript.
• Flex looks like a much better authoring environment than the Flash Authoring Tool – I’ve found the latter to be full of inconsistencies and not “helpful”. Flex looks much more amenable to building applications, which is where I’m focused. And, it’s Eclipse-based.

Why Flash vs. JavaScript or, for that matter, Java?

Easy, in my mind – Flash has a much richer innate graphics set than Java, with a lot of support for animations, curved rectangles, really nice thick line support with endcap definitions, etc. With all that, it’s pretty much guaranteed to be on every platform. There are always performance issues in an interpreted environment – even a byte-code interpreted environment, but Adobe has put a lot of effort into updating the runtime and making it more efficient, and making Flash a more formal and rigorous development platform.

Too bad it doesn’t work on the iPod…

Small systems are making a comeback with a vengeance.

My little Librettos (made by Toshiba) aged beyond usefulness a couple of years ago, and nothing under the 12″ subnotebooks has surfaced since.

Now, Asus (who, I understand, makes my 13″ MacBooks) is hitting the streets with their Eee PC.  The early version were cute, with a 7″ screen like the Libretto, but a bigger keyboard – something you could actually type on.  At a $300 buy-in, my wife (normally averse to impulse technical purchases) fell in love with it on sight and ran off to Paris with it.

That represents potential market share if I’ve ever seen it and, sure enough, manufactures all over the place have yelled Eee!!! and are preparing knockoffs.  MSI, Lenovo, Dell – all are jumping on the bandwagon and producing little machines with 8.9″ and 10″ screens, at prices well under $1000 (the Libretto was priced at $2200 at it’s introduction – way back in the 90’s.)

Asus isn’t sitting still – they’re announcing no less than 22 variants of the Eee, as of this writing.  Talk about throwing spaghetti against the wall!

So this is a good thing!

I’m waiting to snap up a 10″  Eee, I think, as soon as I get home.  Best configuration would be with a 64gb SSD and 2gb of memory, Ubuntu Linux, built-in 3G (and the regular suite of wireless).  Not sure it’s available out of the box like that, but that’s what back-end configuration is all about.

It will be nice to have a little note-taker/dashboard mapper/web-browser that I can carry around anywhere, and that will turn on instantly.  Combined with the 3G, I can be connected anywhere.

rickb