The new version looks quite nice and fresh. Notice the privacy information on the right-hand side, which is relevant as Qaiku allows channels and profiles that are private or invitation-only:

Technically the new version is also remarkable as it is the first major website to run fully on top of the legacy-free Midgard2 platform. So yes, every entry you see there is a GObject. And D-Bus signals fly when you post.

On to the challenge, then

To highlight Qaiku's threading, conversational nature I started a new "On my travels, I have" thread for sharing your most extraordinary travel experiences. This is not on Twitter or Buzz as with Qaiku it is so easy to keep the conversation together and accessible for the future as well.

To contribute, sign up on Qaiku, go to the thread and add your experiences as a comment. If you have a link or picture to include, you can also do so. My first entry was:

seen ice descend from the heavens and provide us with cold beer on a hot day in Lesotho

Will be interesting to see what comes out of this :-)

The idea of a content repository is that instead of coming up with new, isolated file formats or database setups for your application you can just work with objects and signals, and let Midgard handle the rest. This is something that lots of people are doing with CouchDB as well, but we feel Midgard, with its light footprint and native APIs for languages like Python, C, Vala and PHP fits better in the mobile applications context.

Installing Midgard

Midgard packages are available for many different Linux distributions through the OpenSuse Build Service. To find the right repository for your setup, go to the OBS project page. For example, on my Ubuntu Karmic netbook the URL to add to apt sources.list is deb http://download.opensuse.org/repositories/home:/midgardproject:/mjolnir/xUbuntu_9.10/ ./. Then I just:

sudo apt-get update
sudo apt-get install python-midgard2

Midgard is also available in Maemo extras and for OS X on MacPorts.

Defining a schema

The first thing when developing a Midgard application is to define your storage objects. This is done using the MgdSchema XML format. In this case we're doing a simple "attendee" object that amends Midgard's built-in person record with information related to the conference:

<?xml version="1.0" encoding="UTF-8"?>
<Schema xmlns="http://www.midgard-project.org/repligard/1.4">
    <type name="openbossa_attendee" table="openbossa_attendee">
        <property name="id" type="unsigned integer" primaryfield="id">
            <description>Local non-replication-safe database identifier</description>
        </property>
        <property name="person" type="unsigned integer" link="midgard_person:id">
            <description>Person attending the event</description>
        </property>
        <property name="registration" type="datetime">
            <description>Registration date of the attendee</description>
        </property>
        <property name="likesbeer" type="boolean">
            <description>Whether the attendee likes beer</description>
        </property>
    </type>
</Schema>

Then we just save this XML file into /usr/share/midgard2/schema/ so that Midgard will find it.

Initiating the repository connection

Once the MgdSchema is in place it is time to import antigravity and start hacking in Python. The code works pretty much in the same way in other languages Midgard is available for, but Python is used here for the sake of simplicity. First we load the Midgard extension:

import _midgard as midgard

Then we setup the repository connection. With these settings we will store our content into an SQLite database located in ~/.midgard2/data/midgardexample.db:

configuration = midgard.config()
configuration.dbtype = 'SQLite'
configuration.database = 'midgardexample'

# Open a Midgard repository connection with our config
connection = midgard.connection()
connection.open_config(configuration)

As this is the first time we're interacting with the repository we need to tell Midgard to prepare the storage for itself and also for our new openbossa_attendee class:

midgard.storage.create_base_storage()
midgard.storage.create_class_storage('midgard_person')
midgard.storage.create_class_storage('midgard_parameter')
midgard.storage.create_class_storage('openbossa_attendee')

Interacting with data

First we create a person object with our attendee:

person = midgard.mgdschema.midgard_person()
person.firstname = 'Leif'
person.lastname = 'Eriksson'
person.create()

Then we create our attendee object and link that with the person we just created:

attendee = midgard.mgdschema.openbossa_attendee()
attendee.person = person.id
attendee.likesbeer = True
attendee.create()

Querying data

Later we'll want to find out about all Leifs attending the event. We do this by using the Midgard query builder:

qb = midgard.query_builder('openbossa_attendee')
qb.add_constraint('person.firstname', '=', 'Leif')
attendees = qb.execute()

The query builder returns us a list of matching attendee objects. We can go through them and also fetch the associated persons:

for attendee in attendees:
    person = midgard.mgdschema.midgard_person()
    person.get_by_id(attendee.person)
    if attendee.likesbeer:
        print "%s, %s is attending the event" % (person.lastname, person.firstname)

Then we can update the persons with their email addresses:

    person.email = 'leif@vinland.no'
    person.update()

For basic data handling, that's it! When you need more, you can extend objects with file attachments or parameters. You can also create joined records using Midgard views. Midgard provides D-Bus signals, transactions, centralized metadata, synchronization and many other things.

The answer is, we use an open-source platform called "Midgard." We picked it nearly ten years ago, and it has held up fairly well.
...

One of the things we like about Midgard actually makes it rather unsuitable for many simpler publishing scenarios: it is highly object-oriented. This allows us to run multiple sites off largely a single codebase -- at the cost of quite user-unfriendly administrative and authoring facilities.

Also, Midgard is very much a development platform, and we have had to create a fair amount of custom code, especially to handle structured content. In that regard, our CMS experience probably resemble yours. As an industry we remain very far from plug-and-play content management technology for all but the simplest of websites.

While the post contains many negative points about older Midgard (the UIs are a bit better now than they used to be, quite a lot of development has since been happening especially in the LTS branch), it is remarkable that CMS Watch has been able to run their services through the same CMS setup for ten years. This really shows the durability and commitment to long-term stability we have in the Midgard community. We've been doing this for more than ten years, and will likely keep going for quite a bit longer.

As for usability and popularity of Midgard, there is quite little we can do about it in the Midgard1 area, as that is now in long-term support phase that won't allow major changes. But Midgard2 is a new world with new opportunities. Midgard's content repository is pretty much there already, as is the MVC layer, and this spring we should be able to unveil the new, quite revolutionary CMS concept as well. Watch this blog for updates!

First of all, go to meego.com and click login:

Select the "Log in using OpenID" option, and provide your maemo.org OpenID URL:

Then the request will be redirected to maemo.org where the site will check your credentials and ask whether to relay your information on to meego.com:

And that's it, suddenly you can use your maemo.org account with meego.com!

The same OpenID provider component can also be utilized on any other Midgard-powered website.

The idea behind the Midgard content repository is that instead of coming up with your own file formats you can just keep working with objects and signals, and let the repository deal with the rest.

It is always fun to go to Brazil and meet the vibrant free software community there. The plan is to fly over this weekend, spend a few days in Sao Paulo and then head for the Amazon. Feel free to ping me if you're around.

This is another case of location context being used to serve users better. To figure out where the user is coming from the site uses a combination of IP positioning and browser geolocation, while weather information comes from Foreca's feeds. Map visualization uses CloudMade's OpenStreetMap-based maps. And of course the whole thing runs on the stable Ragnaroek series of Midgard.

In other news, Jos et jaksa is another pretty interesting recent site launch, especially for the fact that it is the first-ever website running on the legacy-free Midgard2 platform and Midgard MVC.

If you’re thinking The Tablet is just a big iPhone, or just Apple’s take on the e-reader, or just a media player, or just anything, I say you’re thinking too small — the equivalent of thinking that the iPhone was going to be just a click wheel iPod that made phone calls. I think The Tablet is nothing short of Apple’s reconception of personal computing.

What I find most interesting are the view that the Tablet may bring new computer interaction paradigms. Again from Daring Fireball:

Our “desktop” computers’ human interfaces haven’t fundamentally changed since 1984 — keyboard and mouse/trackpad for input, overlapping draggable resizable windows on-screen, and a hierarchical file system where you create and manage “document files”. Have you ever sat back, scratched your chin, and wondered when the computer industry will break free of these current interfaces — which can be a hassle even for experts, and downright confusing (e.g. click vs. double-click) for the non-experts? Surely no one expects the computer interfaces of, say, 50 years hence to be based on these same metaphors and input methods. What’s the next step?

A touchscreen tablet isn't really suited for the WIMP paradigm as for example text entry is quite difficult, and you probably want larger, thumb-friendly user interface elements. This is where Microsoft's Tablet PC initiative failed, trying to bring the regular WIMP user interface to the tablet.

Instead what seems to be happening is that all the Wiis, iPhones, and N900s are now heading us towards a post-WIMP world. Instead of indirect manipulation by mouse and keyboard we can now interact with our applications using the more natural ways of touching things on screen or moving the device around.

This innovation will not be limited only to mobile APIs, web applications can already now know whether user is accessing them via a WIMP system or a touchscreen device thanks to CSS media queries and Javascript orientation events in latest Firefox.

The user interface innovation that is arriving thanks to these new interaction possibilities is quite promising, though it will probably take a while before we know what things actually work, and what are just fun demos.

If you're thinking about new kinds of user interfaces, it might be a good time to read papers like Noncommand User Interfaces (Jakob Nielsen, 1993) and Magic Ink (Bret Victor, 2006).

I certainly am as we are in the process of defining a new kind of CMS UI for Midgard 2.

Update: Gizmodo has a very nice article on Jef Raskin's information appliance concept and the evolution of GUIs.

• Midgard2 finally became a reality, bringing us a fully legacy-free modern Midgard implementation. There were two releases: 9.03 Vinland and 9.09 Mjolnir. Midgard2 works just fine also in desktop applications and mobile devices like the Nokia N900
• Ragnaroek, the long-term support version of Midgard1 kept chugging along with four new maintenance releases and total of 566 issues closed. Ragnaroek will be maintained until October 2013
• The Midgard Project turned ten years old in May. A gala evening and party was held in Helsinki, Finland
• Midgard's content repository gained bindings to two new programming languages alongside existing PHP, C and Python: Objective-C in March and Vala in December
• Midgard was one of the CMSs admitted to the EU-funded Interactive Knowlegde project that aims to increase semantic capabilities in content management
• Qaiku, a conversational microblogging platform powered by Midgard MVC was launched in March
• We had two Midgard Gatherings: in March in Linköping, Sweden and in October in Helsinki, Finland
• Ragnaland became a way to bridge the gap between Midgard1 and Midgard2 by enabling running of MidCOM applications on top of Midgard MVC
• Midgard was presented in several conferences including Gran Canaria Desktop Summit, FrOSCon, OpenMind and FSCONS
• Founding meeting for an association to support the Midgard project was held in December. The association will provide membership to all active Midgard contributors, and an alumni membership for people who have been part of the project in the past

Happy new year to everybody in the Midgard world!

But to be really easy, the framework you're using should provide user's location built-in, without you as an application developer having to think about it. This is the reason for Midgard's geolocation features to exist, after all. With Midgard, getting user's location is quite easy:

Midgard MVC (Midgard 9.09)

// Read location from session or user's location log
$user_location = midgardmvc_helper_location_user::get_location();
if (is_null($user_location))
{
    // No location found, try to geocode based on user IP via the GeoPlugin service
    $geocoder = new new midgardmvc_helper_location_geocoder_geoplugin()
    $location_parameters = array('ip' => $_SERVER['REMOTE_ADDR']);
    try
    {
        $user_location = $geocoder->geocode($location_parameters);
        midgardmvc_helper_location_user::set_location($user_location);
    }
    catch (Exception $e)
    {
        // Couldn't get location from IP
    }
}

if (!is_null($user_location))
{
    echo sprintf('You\'re in %s, %s', $user_location->latitude, $user_location->longitude);
    // Will print "You're in 60.1633, 24.9279"
}

MidCOM (Midgard 8.09)

<?php
// Read location from session or user's location log
$user_location = org_routamc_positioning_user::get_location();
if (is_null($user_location))
{
    // No location found, try to geocode based on user IP
    $geocoder = org_routamc_positioning_geocoder::create('geoplugin');
    $location_parameters = array('ip' => $_SERVER['REMOTE_ADDR']);
    $user_location = $geocoder->geocode($location_parameters);
    if (!is_null($user_location))
    {
        // Store geocoded location to session or user's location log
        org_routamc_positioning_user::set_location($user_location);
    }
}

if (!is_null($user_location))
{
    echo sprintf('You\'re in %s, %s', $user_location['latitude'], $user_location['longitude']);
    // Will print "You're in 60.1633, 24.9279"
}
?>

The examples above will work with both anonymous site visitors (using sessions) and registered users (using Midgard's position log). In this example we check if location is already available via browser geolocation or some importer like Qaiku or Fire Eagle, and if not we fall back to IP-based positioning using the GeoPlugin service. The resulting user location array or object (depending on Midgard used) contains a textual description of the place and accuracy information in addition to WGS-84 coordinates.

This is built on top of the excellent FirePHP extension, which helps you get data not only from regular web pages but also from AJAX requests.

Currently we send all logged information plus details about current route and templates being used. To use this, install FirePHP in your Firefox, FirePHPCore from PEAR packages, and enable development_mode in MidCOM3 configuration.

I'm considering to port this also to Ragnaroek.

Web Content Repositories are more than just plain old relational databases. In fact, the requirements that arise when managing web content have led to a class of content repository implementations that are comparable on a conceptual level. During the IKS community workshop in Rome we got together to compare JCR (the Jackrabbit implementation) and Midgard's content repository. While in some cases the terminology might be different, many of the underlying ideas are identical. So we came up with a list of common traits and features of our content repositories. For comparison, there is also Apache CouchDB.

So, why use a Content Repository for your application instead of the old familiar RDBMS? Repositories provide several advantages:

• Common rules for data access mean that multiple applications can work with same content without breaking consistency of the data

• Signals about changes let applications know when another application using the repository modifies something, enabling collaborative data management between apps

• Objects instead of SQL mean that developers can deal with data using APIs more compatible with the rest of their desktop programming environment, and without having to fear issues like SQL injection

• Data model is scriptable when you use a content repository, meaning that users can easily write Python or PHP scripts to perform batch operations on their data without having to learn your storage format

• Synchronization and sharing features can be implemented on the content repository level meaning that you gain these features without having to worry about them

In addition to being a GObject-powered content repository for PHP, Python and Objective-C, the Mjolnir release provides several significant goodies on top of the older Midgard2 series:

• MgdSchema Views provide a way to define joined data types
• MgdSchema types can be extended with subclasses and additional information
• Transactions are available for storage engines that support them
• New authentication API provides support for different types like OpenID and OAuth
• ...and there are a lot more unit tests, helping to safeguard against regressions

We've been testing running the Qaiku microblogging service with Mjolnir. The exactly same PHP code that we used with Midgard 8.09 LTS performs 20-60% better when running on Mjolnir.

Get Midgard2 9.09 Mjolnir while it is hot! Builds for various Linux distributions are already starting to hit OBS repositories...

There are many examples of this happening, from Facebook's framing of web to netbooks systems like the JoliCloud not having an address bar. Certainly many companies are looking at Mozilla's search engine revenue and Apple's app store model and want to emulate that, moving the web into silos of their own control. But at the same time, we're thinking of Linked Data and open, interoperable web standards.

Web indeed is at new crossroads.

Chris Messina predicts the death of URLs:

a future without URLs and without the infinite organicity of the web frightens me. It’s not that I know what we’ll lose by removing this artifact of one of the most generative periods in history — and that’s exactly the point! The URL and the ability for anyone to mint a new one and then propagate it is what makes the web so resilient, so empowering, and so interesting! That I don’t need to ask anyone permission to create a new website or webpage is a kind of ideological freedom that few generations in history have known!

Tim O'Reilly presents a call to arms:

It could be that everyone will figure out how to play nicely with each other, and we'll see a continuation of the interoperable web model we've enjoyed for the past two decades. But I'm betting that things are going to get ugly. We're heading into a war for control of the web. And in the end, it's more than that, it's a war against the web as an interoperable platform. Instead, we're facing the prospect of Facebook as the platform, Apple as the platform, Google as the platform, Amazon as the platform, where big companies slug it out until one is king of the hill.

And it's time for developers to take a stand. If you don't want a repeat of the PC era, place your bets now on open systems. Don't wait till it's too late.

• Midgard Weekly Summary #75: October 2nd 2009

MWS has been running before, with 66 issues released between 1999 and 2002, and 8 issues in 2007. This time we follow the idea of a Collaborative MWS.

Notices about new published summaries will be sent to the Midgard user mailing list, Qaiku #midgard channel, Twitter @MidgardProject and are available via RSS. Enjoy!

Technorati Tags: midgard

• September 30th - October 1st: OpenMind and MindTrek in Tampere, Finland
  I'll give a talk about the Midgard project and how our company has evolved together with it. In addition Linux-tekijä awards, where I was in the awards committee, will be announced
  
  
• October 9th - 11th: Maemo Summit in Amsterdam, the Netherlands
  While I'm not giving a talk in the event it will be great to meet the rest of the maemo.org team, and the community around the project
  
  
• October 17th: Finhack in Forssa, Finland
  A free-form hacking event for the Finnish free software community. Expect some progress with Midgard's XMPP capabilities
  
  
• October 23rd - 25th: Midgard Gathering Helsinki, Finland
  Midgard users and developers get together to learn about the new capabilities of Midgard 9.09 Mjolnir and discuss the roadmap for the next release
  
  
• October 29th: The Open Web in Ede, the Netherlands
  NLUUGs conference on new web technologies where I'll be speaking both about GeoClue and the Midgard Content Repository
  
  
• November 11th - 13th: Semantic Search workshop in Rome, Italy
  Together with a general meeting of IKS Project participants
  
  
• November 13th - 15th: FSCONS in Gothenburg, Sweden
  The annual Nordic free software gathering where I'll be speaking about Midgard2

Looking forward to all the interesting discussions and ideas that will surely come up from these events. If you will be around in one of those, make sure to look me up and we can chat. The events will also be covered in my Qaiku stream.

"See — the problem with a full scale Content Management System is that it has too many opinions. Those opinions were though of by somebody other than you and the needs of your organization. The more developed a content management system (or any piece of software, really) the more “opinions” it has. And the more “opinions” it has, the more likely one of them is going to really tick you off."

I can relate to this. We work with one system in particular that makes an astonishing array of presumptions about how you’re going to use it, and if you try to step outside those presumptions, demons fly out of the abyss and try to suck your eyeballs out.

This goes back to a previous discussion we had about Content Management as an API. In that post, we had a great experience with hand-rolling a CMS...

The term they are looking for is Content Repository, a service that provides common APIs for content storage, retrieval, signaling and so forth. With Midgard we're following this approach, providing content retrieval and web functionality APIs first, and then building some reusable user interfaces on top of that.

In addition to Midgard some content repositories to look at include Apache CouchDB and Jackrabbit. All of them allow you to stop worrying about storage and retrieval methods and focus on the actual end user functionalities, while keeping the whole system accessible and scriptable for integration purposes.

Technorati Tags: couchdb, jcr, midgard

Midgard2 is a more universal content repository where CMS is just one application:

Please note that more choice in databases and web servers is not the only goodie provided by Midgard2. You also get things like a completely rewritten MVC framework, database views, transactions and native datetime objects. And all of this for multiple programming languages, not just PHP.

Technorati Tags: midgard

Content repositories allow you to separate the actual front-end of your application from background processing tools. More than just their underlying databases, they impose common rules for data access, and keep multiple applications up-to-date on data changes through signaling. Midgard2 provides a flexible content repository that avoids the restrictions of the traditional ORM approach. And not only your PHP web application, but also to possible Python, Objective-C and C# tools you use.

This enables you to split applications into smaller, easily maintainable and scalable pieces that can be run on different systems and platforms as needed. In addition to web, the Midgard2 library can be used for desktop and mobile application development, building software that synchronizes with web services. It is based and engineered fully on the top of the desktop (GNOME) software stack. Being highly modular and having very little dependencies it scales from a note taking application to a full-blown CMS system. Combined with advanced replication capabilities it allows you to synchronize data between offline and online instances of your service.

Unlike shown in the program, the talk will be given by Arttu Manninen this time, as I will be off motorcycling somewhere around Asia Minor. Arttu? Yep, this guy:

Technorati Tags: froscon, midgard, php

Sure, the applications still give you a way to share things and take them out of the storage. You can export a contact out of your address book as a vcard file. But the role of The File here is slowly being reduced to a role of an intermediate storage medium. The business card is temporarily put in the .vcf file before it gets injected into somebody else’s database (another address book?).

As more and more applications operate on databases, the computer is becoming a monolithic black-box that “has things”. How exactly (and where) the data is stored is becoming less clear. The application and the interface becomes united with the user data. It becomes one.

This echos the sentiments of Alex Payne when he warned against what he calls Everything Buckets:

Computers work best with structured data. Everything Buckets discourage the use of structured data by providing a convenient place to commingle “structureless” data like RTF and PDF documents. Rather than forcing the user to figure out the rhyme and reason of their data (for example, by putting receipts in a financial management application and addresses in an address book), Everything Buckets cry: “throw it all in here! Search it! Maybe I’ll corrupt my proprietary database, but maybe I won’t and you’ll have the joy of sifting through a mire of RTF documents. Doesn’t that sound great?”

And yes, I agree that obscure application-specific databases are not really better than obscure proprietary file formats.

This is exactly why I've been talking about content repositories, services like Midgard2 and CouchDb that not only can provide superior content storage and organization, but do it in a way that multiple applications can share. You can easily write your own scripts to perform batch operations on the data, and receive D-Bus notifications when something changes.

And good repositories also provide easy synchronization tools so you can have your data available on all of your computers, and even on the web. If they can also do peer-to-peer sharing, we're close to achieving the fully free cloud.

Technorati Tags: couchdb, gnome, midgard

I gave my Midgard2: Content repository for desktop and the web talk yesterday in GCDS. The slides are available on SlideShare. The main idea was that any application that deals with structured data could benefit from using a content repository like Midgard2 or CouchDB.

So, what is a content repository? It is a service that sits between an application and a data store. It provides several advantages:

• Common rules for data access mean that multiple applications can work with same content without breaking consistency of the data
• Signals about changes let applications know when another application using the repository modifies something, enabling collaborative data management between apps
• Objects instead of SQL mean that developers can deal with data using APIs more compatible with the rest of their desktop programming environment, and without having to fear issues like SQL injection
• Data model is scriptable when you use a content repository, meaning that users can easily write Python or PHP scripts to perform batch operations on their data without having to learn your storage format
• Synchronization and sharing features can be implemented on the content repository level meaning that you gain these features without having to worry about them

Midgard2 is a content repository library that is built on top of glib, libgda and dbus, making it fit the general free desktop infrastructure very well. You can use it in any application that is written in C, Objective-C, Python, PHP, or soon Mono. Learn more from the slides!

Technorati Tags: couchdb, gnome, midgard, mono