Today Arch Linux updated the KDE desktop packages to 4.3 and I’m really really impressed.

Everything feels snappier, loads and renders faster. Konqueror displays sites WAY faster. Kwin also leaves a better impression. Here and there some eye candy got added, but always in non distracting ways. Generally, the desktop elements feel more mature and are kept out of my way (e.g the notification messages).

The few rendering issues I had in the past (the “ExaOptimizeMigration” stuff) disappeared as well.

Great release!

Adding emacs 23 released last week, I’m really pleased with my current desktop.

2005,2006,2007,2008,2009,2010: The year of the linux desktop ;)

I couldn’t find a conversion script so here is my own. The days when I was still writing Trac plugins in python are long gone (3 years) so the script became unnecessarily verbose, has no error handling and a bit awkward but it works so far.

Usage: $> python trac2tex.py content.txt

#!/usr/bin/python
# -*- coding:iso-8859-15 -*-
#
# Converts trac content into tex.
# Supports headings and enumerations
#
 
import re,sys
curInd = 0
 
def sectionize(name, ind):
    print '\\' + {1: 'section',
                  2: 'subsection',
                  3: 'subsubsection',
                  4: 'paragraph'
                  }[ind] + '{' + name + '}'
 
def itemize(item, ind):
    global curInd
 
    if ind < curInd:
        enditemize()
    elif ind > curInd:
        out(ind, '\\begin{itemize}')
        curInd = ind
 
    out(ind,'\\item ' + item)
 
def enditemize():
    global curInd
 
    if not curInd:
        return
 
    curInd -= 1
    out(curInd,'\\end{itemize}')
 
def texify(text):
    for i,j in {'ü':'\\"{u}',
                'ä':'\\"{a}',
                'ö':'\\"{o}',
                '!':'',
                '&':'\\&',
                '_':'\\_'}.iteritems():
        text = text.replace(i,j)
 
    return text
 
def out(ind,text):
    print '\t' * curInd + text
 
f = open( sys.argv[1],'r')
 
for line in f:
    line = texify(line) 
 
    #trac * items
    item = re.search( '(\s+)(\*\s?)(.+)', line)
    if item:
        itemize(item.group(3), len( item.group(1)))
        continue
    else:
        enditemize()
 
    #trac titles
    title = re.search( '(=+)\s([^=]+)\s', line )
    if title:
        sectionize(title.group(2),len(title.group(1)))
        continue
 
    print line
 
while(curInd):
    enditemize()

Until now.

Yesterday glibc got updated to 2.10.1-2 and since then DNS does not work for me anymore. I can ping hosts but whenever an application tries to resolve a host name a timeout error occurs. I read somewhere this is likely due to some IPv6 problem of my router’s DNS server. Forced usage of IPv4 as in wget -4 nzz.ch still works but obviously this is no solution.

I normally like to fix those things on my own, (Firmware Update?, OpenDNS?) but my Bachelor Thesis’ deadline approaches so I just downgraded again with a simple

pacman -U /var/cache/pacman/pkg/glibc-2.9-7-i686.pkg.tar.gz


However, the IBM model is not the only one which uses those switches. daskeyboard also sells those kind of keyboards.

I’ve been using one for almost half a year now and if you are thinking about buying one: It is definitely worth it. Those clicky mechanical sounds make you feel happy when writing. Its solid pressure point and tactile feedback makes you go on typing forever. Because the fingers can rest on the keys and there is no tension required to keep them from falling and pressing wasd, you can type for hours without getting that fatigue finger-feeling usually caused by membrane-based ones.

And there is even a version with blank keys. How cool is that!

(at least I thought so until I wanted to take a print screen)

The last time I checked there were still many open questions and issues so I quickly forgot about it. However, yesterday I realized that suddenly everything is ready: The vote is scheduled for March 16.

A list of candidates is available here http://community.haskell.org/~eelco/poll.html

I’m going for #83

Heh, seriously, there are some really great ones (#92) but in my opinion it should be simple and not over-emphasize the lambda.

At the moment I tend to #15, #35 and #64.

I’ll let you know when the results are here.

mhh.. or maybe #100!!!

CPU 0: Machine Check Exception: 0000000000000004
Bank 4: b200000000430a0a
Kernel panic - not syncing: CPU context corruption

when the processor is under heavy load, it’s not a wrong kernel option you’ve chosen.

You might want to update the firmware from 0504 to 0604. (don’t search for your old and dusty floppy drive, the BIOS can read from a FAT formatted USB stick) and those problems go away.

It’s soooo fast!

Really impressing. Browsing feels fun again, especially with heavy javascript pages.

What evil things Google plans to do with this browser remains to be seen…

The long awaited euro 2008 has started. Flags are decorating my window, beer and grill is ready and we will watch the matches the whole month. No time for blogging.

But it’s better like this anyway, to not stay at the computer and doing those nerdy things all the time. You know.. now we have time for things like this

My friend giusi and I will blog a bit about the tournament here.

As I wrote last time my new laptop arrived, I still think it’s a great laptop but not as great as it would explain blogging inactivity for more than a month.

Many thing happened in the meantime, firefox is becoming emacs so emacs should better get the next firefox first, jeff the obvious has something new going on, subversion is considered a dead patient (at least where I hang around when I’m online).
Of course not everybody shares my observations. I heard others are more worried about missing potatoes for the next month than JVM’s balls of steal. Ah yeah, there was also a guy who asked me why I use emacs as its not installed anywhere. He got used writing in vi and it’s on all boxes and wherever he sshs into he finds a familiar environment. Heh, I demonstrated tramp and laughed is his face.

However, that doesn’t explain what I’ve been doing.

Well… I’ve been busy. Not just busy as usual, really busy. I guess the underlying problem is my new strategy how tasks should be handled. You know, I adopted the maybe greatest philosophy ever and converted myself into a lazy evaluation person.
That means, I’m doing nothing for a long time until something should be actually delivered and then, and just then I start focusing on the tasks.
The huge advantage is that you just spend time doing what is really necessary and have more time for other things.
The downside however is the work-explosion you cannot predict before no matter how hard you try. Nobody can. Thus when you finally started you just pray you don’t run out of resources.

One thing I was doing was dealing with was the .NET XmlSerializer.
And I tell you, that’s a piece of crap. Normal people like you and me tend to introduce interfaces, abstract base classes and many other things to keep things somehow modular so they can be kept in the context in our heads.
But exactly those abstractions cannot be serialized. As soon as the serializer discovers that the type of your property is an interface it will throw an exception back to you and tells you to change your design because it’s too complicated to serialize.
One way to solve the serialization problems is to duplicate all problem-properties and map them all to object properties but that’s exactly what you wanted to avoid in the first place.
The second approach is to tag the base class (if there is any) with XmlInclude tags for all existing inherited classes. But as you normally don’t have the control over your base class or just can’t update it whenever you add new extended implementation you cannot make use of it anyway.
The third approach is to use the IXmlSerializable interface. By implementing it, you can override the way how your class is converted into an Xml document and deal with interfaces and base classes on your own. Wohooo!
However, after five classes I noticed that it is a pretty tedious job to implement the same similar logic all over the place. So I implemented a somehow generic solution which scans with reflection over the properties of a type and if it finds something with an interface or inherited class it stores further type hints as attributes so it can convert it back later.
Of course I chose the latest option and in my base classes I can now write

public class Car
{
 IEnginge Engine{get;set;}
 IList<IFoo> Foo{ get;}
 BaseDescriptor Desc{ get{ return new ExtendendDescriptor()} }
 WriteXml( XmlWriter writer )
 {
  Serializer.WriteXml( this, writer );
 }
  ReadXml( XmlReader reader )
 {
  Serializer.ReadXml( this, reader );
 }
}

And all kinds of interfaces, generics, lists and dictionaries can be serialized with the implementation in Serializer. Mishto!

Though it’s not a very elegant solution neither those 2xml conversions. Actually I still don’t get the hype around that text format. Obviously it’s great (and even the first time) that your application achieves standard compliance and interoperability by just choosing the right library and not everybody is busy implementing their own buggy text parser but still… for logical representations it’s not the right thing in my opinion. The only really cool thing I found are XPath queries but that’s already it.

However, the main part of the time I spent with all my vapor projects and I somehow doubt that any of them will be finished until summer. Obviously that’s very normal with vapor projects just I made the mistake to actually talk about them and mentioned release dates.

But seriously guys, you actually think I have time for that? I mean, do I look like?
And it is not just the actual coding itself, using immature languages will bring you enough trouble anyway and when you don’t have time to fix the main libraries of that language, don’t want to monkey patch everything or don’t have the time to write new bindings every second hour then you just have yet another unfinished project in your repository.

Yes obviously I should have used something more proven but limitations get just discovered above a certain project-size anyway. When the developed program suddenly gets incredible slow or shows (at least in the eyes of the naive programmers like I am) strange behavior. Though at least you start getting a feeling which things might be problematic when faced with a new language and may explore their limits right in the beginning and don’t run into huge problems because of some half-baked implementations you are depending on at a later stage.

Ah where was I… right, problems with static languages. Did you notice that everybody started to ditch their old fat static language and went over to the dynamic camp? Oh and I’m not just talking about far away from here somewhere in the interwebs. It seems to be happening right down the street at the next corner. Who knows where this will lead us to?
It ends up into a maintenance hell with many different languages and their incompatible flavors as a result of constant forking and a too dynamic development path? Where it’s faster to rewrite the program for every new feature and where the non technical java-is-great managers won and don’t want to hear about the introduction of yet another language and framework?
Or we get a truly great environment with easy interoperability and robustness which attracts even more dynamic kids to jump in.

Today’s situation with the current languages seem do match the first option more thus the ongoing adoption of dynamic idea let us hope for a shift to the second one in near future. As soon as it would get widely accepted there would be yet another division in our industry. It will be way harder to hide missing knowledge or unwillingness to contribute behind strategyBridgeAdapter patterns or endless abstractions over abstractions. What the blubs will do is another question but there will be enough things left to do anyway.
Moreover, there would be finally a supporting type system which wouldn’t just put obstacles in our ways.

Time will show. Anyway, I wish our application would have been written in a dynamic language like lisp. Instead of converting some parts of the program into an xml file and then parse it back, the saved data could be lisp code on its own which could be loaded straight into the application without tedious parsing.

What a great world that would be.