/usr/portage

Meine Lieblingsalben 2000 – 2009

nospam@example.com (Lars Strojny) — Thu, 31 Dec 2009 15:10:36 +0100

Zur Jahreswende ist es Zeit auf die letzten zehn Jahre Popmusik zu schauen. Allen ein gutes neues Jahr zu wünschen, wann auch immer es in den jeweiligen Kalendern beginnt.

20 Matisyahu Youth 2005

19 Joanna Newsom Ys 2006

18 The Shins Oh, Inverted World 2001

17 Rufus Wainwright Release the Stars 2007

16 Architecture in Helsinki Fingers Crossed 2003

15 Morrissey Years of Refusal 2009

14 Editors The Back Room 2005

13 The Kooks Inside In/Inside Out 2006

12 Gossip Standing in the Way of Control 2006

11 The Good, The Bad & The Queen The Good, The Bad & The Queen 2007

10 The Knife Deep Cuts 2003

09 Element of Crime Mittelpunkt der Welt 2005

08 Bloc Party Intimacy 2008

07 Arctic Monkeys Whatever People Say I Am, That's What I’m Not 2006

06 Maxïmo Park Our Earthly Pleasures 2007

05 Johnny Cash American V: A Hundred Highways 2000

Mit der Veröffentlichung von American V: A Hundred Highway nach dem Tod Johnny Cashs geht ein Stück Musikgeschichte zu Ende. Die American Recordings-Serie zeigt Cash auf dem Höhepunkt seines musikalischen Schaffens. Wer hat nicht wenigstens eins dieser Stück gehört und nicht wieder vergessen: The Beast In Me, Bird On A Wire, I See a Darkness, I Won’t Back Down, The Mercy Seat, Solitary Man.

Den Tracks des letzten Albums ist der Gesundheitszustand Cashs aufgeprägt: seine brüchige Stimme verstärkt die Melancholie, die der ganzen Serie anhaftet. Unvergessen das Celebrity-Tribute-Video zu God’s Gonna Cut You Down.

Die letzte Platte ist nicht die beste der Serie, sie ist aber sicher die beeindruckenste. Ob aus pragmatisch-ökonomischen Gründen, wie bei Veröffentlichung gelästert wurde, oder aus edleren Motiven: ein Album zu veröffentlichen, auf dem deutlich zu hören ist, dass es das letzte sein wird, zwingt den Zuhörer zu irgendeiner Art von Reaktion. Und wem Cashs Musik etwas bedeutet, der wird gerade dieses Album in seiner bitteren Süße genießen.

04 Modest Mouse Good News for People Who Love Bad News 2004

Wenn wir schon bei Rockmusik sind: im Sommer 2007 empfahl mir ein Bekannter Modest Mouse als ein wenig verspult aber interessanter Sound. Und er meinte nicht nicht picky-interessant, sondern interessant-interessant. Also hörte ich mir das an und reagierte erstmal zurückhaltend. Ja, lustiger Albumtitel, ja, Musik ist Okay aber mehr war erstmal nicht. Aus heute nicht mehr nachvollziehbaren Gründen hörte ich das Album aber weiterhin an und irgendwann gefiel es dann doch. Sogar ziemlich gut. Jedenfalls so gut, dass ich kurz darauf Modest Mouse live sah, mir den Rest Ihrer Alben besorgte und immer weiter hörte.

Good News for People Who Love Bad News klingt wie heiser und aggresiv – wie Musik manchmal sein muss. Die Gitarren schrammeln, das Schlagzeug treibt, Rockstruktur halt.

Lieblingstitel

02: World At Large
03: Float On
06: Bury Me With It
08: Bukowski

03 Eels Souljacker 2001

Life ain’t pretty for a dog faced boy heißt es im Refrain von Dog Faced Boy. Life ain’t pretty for the E man würde genauso passen.

Mark Oliver Everett hat mit Eels bis heute eine Reihe von Platten hingelegt, die so unfassbar gut sind, dass selbst die schlechten noch die musikalische Konkurrenz bei weitem übertreffen. Aber über die schlechteren wollen wir nicht reden, wir reden über Souljacker. Souljacker ist deswegen so interessant, weil es all dass, das Eels kann, auf eine Platte presst. Da geht es krächzend los mit Dog Faced Boy und That’s not Really Funny, dann folgen Fresh Feeling und Woman Driving, Man Sleeping ganze ruhige Stücke, die sogar mit Streichern umso besser funktionieren, nur um wieder von einem klassischen Rock-Arrangement, nämlich Souljacker I, abgelöst zu werden. In Friendly Ghost verschmelzen die beiden Stilrichtungen und werden angereichtet mit Elementen des Folk zu einem netten 3:23 Stückchen.

Zwischen 2000 und 2009 sind ganze sieben Eels-Alben erschienen, nur eines zu loben wäre unaufrichtig. Souljacker ist die Verdichtung aller anderen Alben, die hier aber nicht unerwähnt bleiben sollen. Wer den symphonischen Teil weiter kennenlernen will, kann auf With Strings: Live at Town Hall Neuinterpretationen der Eels-Stücke mit Orchester lauschen, wem nach poppigen Arrangements zu Mute ist, der wird mit Daisies of the Galaxy glücklich.

02 Tocotronic Kapitulation 2007

Der deutschen Poplandschaft entsprießten um die Jahrtausendwende ein Haufen musikalisch und textlich ausbaufähiger Bands wie Juli, Echt, Silbermond oder Revolverheld. Ausbaufähig ist eine freundliche Untertreibung, solcher Quatsch sucht seinesgleichen. Diese Bands mussten immer betonen, wie sehr sie von Tocotronic beeinflusst wurden. Diese Entwicklung griffen Tocotronic 2002 mit ihrem Album Tocotronic, auch als Weißes Album bekannt, auf. Sicher auch aus dem Bedürfnis der Abgrenzung heraus wurde die vormalige Sloganhaftigkeit mehr und mehr verdrängt durch diffizilere, lyrische Texte.

Reise nach 2007: Seit 1998 war die Schröder-Regierung an der Macht: Deutschland war im Reformfieber, seitdem wird gefördert und gefordert, ohne Eigeninitiative geht gar nichts mehr. In dieses Treiben hinein veröffentlichte Tocotronic 2007 ihren Aufruf, den Quatsch einfach mal sein zu lassen. Nicht als aufdringliche Liedermacher-Dichtung, sondern als höflicher Schubser, wegzulaufen, sich zu verstecken – eben zu kapitulieren, wenn man es nicht mehr aushält.

Der Klang der Platte ist, trotzdem sie als Themenalbum angelegt ist, typisch für die ehemaligen Neulinge der Hamburger Schule: gitarrenlastig, roh. Über den Klangteppich breitet sich die Nichtstimme von Dirk von Lowtzow, die mal brüchig und zurückhaltend wie in Dein geheimer Name oder stampfend wie in Sag alles ab das stimmliche Spektrum der Band beleuchtet. Die Platte kann einfach als Rockmusik gehört werden, als poetisches Album voller versteckter Referenzen oder eben als auch als politisches Konzeptalbum. Die Vorgänger-Alben waren richtig und wichtig, doch nie war Tocotronic auch musikalisch so gut.

Lieblingstitel

02: Kapitulation
06: Harmonie ist eine Strategie
10: Sag alles ab

01 Arcade Fire Neon Bible 2007

Mit Neon Bible zeigten Arcade Fire 2007 was sie können: ungewöhnliche Arrangments an den Genre-Grenzen von Folk und Rock unterlegt mit ungewöhnlichen Instrumenten wie Orgel und Akkordeon. Was auf dem Vorgänger Funeral schon anklang, Dunkelheit, Hysterie, drückende Hitze, wird hier zur Perfektion getrieben. Wer behauptet, nach Pink Floyd könne im Pop niemand mehr Songs die Anmutung von Opern-Arien geben, sieht sich getäuscht. Der Qualität von Neon Bible können auch die in reaktionäre Sehnsucht sich wendenden Texte kaum etwas anhaben: zu berauschend, zu atemberaubend ist die Schönheit dieser Aufnahme.

Und weil ich in den letzten zehn Jahren einfach kein Album gehört habe, dass mich dermaßen gefesselt hat, muss es auf Platz 1 landen.

Lieblingstitel

01: Black Mirror
03: Neon Bible
04: Intervention
11: My Body is a Cage

Batch-generating SSL certificates

nospam@example.com (Lars Strojny) — Fri, 14 Aug 2009 22:07:28 +0200

I had an itch to scratch this day: generate a huge amount of SSL-certificates for a set of whitelabels. Every whitelabel has it’s own domain and needs it’s own SSL certificate. I don’t want to spend n ⋅ x ¤ to buy them just for testing purpose (generating a huge number would have been an issue too if I bought them but …). So I needed a script to do it. We had one before to generate a single one with the typical user interactions. While hacking it down I found out a few neat things about OpenSSL which I didn’t know before and which I think are worth sharing.

Disclaimer: the script is not hacked together with security in mind. It simply doesn’t matter for me in this specific case.

So after alot of chit-chatting, there we go:

#!/bin/bash
DOMAIN="$1"
if [ -z "$DOMAIN" ]; then
    echo "Usage: $(basename $0) <domain>"
    exit 11
fi

Obvious: we need to call the script with a domain as a parameter. Next is a simple to fail when a certain condition matches:

fail_if_error() {
    [ $1 != 0 ] && {
        unset PASSPHRASE
        exit 10
    }
}
export PASSPHRASE=$(head -c 128 /dev/random  | uuencode - | grep -v "^end" | tr "\n" "d")

We generate a passphrase by reading 128 byte from /dev/random, encoding it with base64 and joining the lines. A simple trick if you can’t rely on pwgen or makepasswd. Next is to define the subject string. But we’ll talk about that later:

subj="
C=<Country Code>
ST=<State>
O=<Company>
localityName=<City>
commonName=$DOMAIN
organizationalUnitName=<Unit Name>
emailAddress=<email>
"

Of all things generating a fresh RSA key comes first. The neat trick to avoid user interaction here is to use -passout option. This option takes an protocol argument similar to PHPs stream wrappers. env:<envvar> for environment variables, pass:<password> if you like to pass the string directly, file:<filename> to read from a file, fd:<number> to read from a file descriptor and stdin – well – to read from the standard input. Of course we fail on error.

openssl genrsa -des3 -out $DOMAIN.key -passout env:PASSPHRASE 2048
fail_if_error $?

Now we generate a certificate request (.csr). -batch simply supresses user interaction. And here comes the $subj variable into play which allows us to override our certificate requests defaults specified in our openssl.conf. Most of the time the OpenSSL configuration file should be located in /etc/ssl/openssl.cnf but if you are on Mac OS X it is located in /System/Library/OpenSSL/openssl.cnf. The subject variables you can override are defined in this configuration. It’s an INI file, just search for the section [ req ] and look at the keys distinguished_name and req_attributes. There values redirect to the section name we are searching for: here you can find the candidates you might want to override in your subject string. Just extend the $subj variable according to your needs. The $subj variable lines are joined with a slash as a seperator – this is how OpenSSL likes it.

openssl req \
    -new \
    -batch \
    -subj "$(echo -n "$subj" | tr "\n" "/")" \
    -key $DOMAIN.key \
    -out $DOMAIN.csr \
    -passin env:PASSPHRASE
fail_if_error $?
cp $DOMAIN.key $DOMAIN.key.org
fail_if_error $?

Strip the passphrase from our RSA-key to not get prompted when Apache (or any other webserver) starts:

openssl rsa -in $DOMAIN.key.org -out $DOMAIN.key -passin env:PASSPHRASE
fail_if_error $?

Last step, create the certificate file:

openssl x509 -req -days 365 -in $DOMAIN.csr -signkey $DOMAIN.key -out $DOMAIN.crt
fail_if_error $?

Now: deploy the .key and .crt file to your webserver and set up your configuration.

Dokumentation über Adorno und die Kritische Theorie

nospam@example.com (Lars Strojny) — Sun, 31 May 2009 15:29:51 +0200

Theodor W. Adorno – Dokumentation 1. Teil

Theodor W. Adorno – Dokumentation 2. Teil – “Wer denkt, ist nicht wütend”

An introduction to Domain Driven Design

nospam@example.com (Lars Strojny) — Wed, 13 May 2009 00:54:33 +0200

My collegues asked me to write down some documentation on the basic concepts of domain driven design. Why not make a blog post out of it?

Domain Driven Design is all about the domain. The premise is, that what we call model, is the model of the real world process we are going to implement (the “domain”). DDD focuses on the domain of the problem, not on data, not on functions, not on control structures (although all of this stuff is used to implement them). Object technology fits pretty well into DDD as it allows us to narrow reality, as we can express behavior and state together (in an object).

A short glossary

Domain Layer

The layer in the application where the domain is expressed in terms of objects.

Domain Objects

All the objects in the domain layer

Entity

Entities are those domain objects that are equal by identity as they express a specific state of a specific entity in the system. Examples are a customer or a purchase.

Value Object

The opposite of entities in the domain layer. Objects that are equal because of equal values not because they are identical. A money object is a typical value object and so is an address.

Aggregate

An aggregate is an objects graph in the domain layer consisting of entity and value objects. A customer has a number of addresses and an order has a money value object.

Aggregate root

The top level object in an aggregate. In the customer example, the customer is the aggregate root and all the other objects are aggregations to the customer.

Repository

The repository acts like a Facade to the ORM components of a system. In DDD we focus only on the domain, we don’t care about ORM, we are ignorant against ORM. The repository allows us to be ignorant as it provides a simple, collection like interface to the user. Think of the repository as a factory to the persisted objects with a collection interface and being a facade to keep away all that sad details of ORM.

Ubiquitous Language

At the beginning everything is messy: you think that girl is stupid, she thinks you are a quirky nerd with strange hobbies and even more strange friends. A few dates later you both find an ubiquitous language which allows you to communicate efficiently. DDD encourages to find a set of terms to describe the system, that is modeled after the language of the domain. So the knowledge gathered in the development team about the domain is directly build into the systems core.

Leaflet: PHP development in 2009

nospam@example.com (Lars Strojny) — Sat, 02 May 2009 19:25:57 +0200

Develop object-oriented code
- Avoid static cling
- Avoid global state
- Use dependency injection
- Use a framework if appropriate
- Refactor continuously
Use a VCS, preferably a decentralized
- Have commit notifications configured
Utilize continuous deployment
- Deploy with tools like capistrano
- Deploy phar files
Test your code
- Use continuous integration to run tests, create and deploy artefacts
- Unit test your code with PHPUnit or SimpleTest
- Have database migration in place to ease schema changes, e.g. with dbdeploy
- Use build tools like phing or ant
- Have metrics configured and use them as a QA measure
- Have a code sniffer in place
- Acceptance tests with tools like Selenium
Use rapid development tools like Zend Tool or cake
- A fresh checkout should be up and running in a few minutes
Monitor your (production) systems
- Load monitoring with tools like Cacti
- Event reporting and monitoring with tools like Nagios (for the enterprise, there is nothing else)
Use a bytecode cache
Love your code

What do you think is the state of the art in 2009?

Speaking at IPC Spring ’09

nospam@example.com (Lars Strojny) — Tue, 10 Mar 2009 00:29:47 +0100

I’m giving a talk at International PHP Conference Spring Edition in May in Berlin. I will talk about Beatiful (PHP) code: code your ~~mother~~ domain experts can read, code that talks, code that reveals intention and what does it mean on the architecture side. So, a somewhat impractical and detached topic. I’m looking forward to see you in Berlin.

Not having globals state doesn't mean you're doomed

nospam@example.com (Lars Strojny) — Sun, 15 Feb 2009 03:08:19 +0100

hbp_pix©

A pretty popular myth about avoiding global state (singletons, multitons, registries, global variable, static variables/methods) is that it results in creating widely used objects more often than needed. The most common example in this case is a database connection. We try to avoid global state to let objects express their dependencies clearly: the object constructor should be as readable as “give me this, give me that and I will work”. Let’s talk about a situation where we instanciate a relatively complex set of domain objects including a service layer. For the example, we assume that we read an existing customer. We use the CustomerServiceLayer to retrieve the Customer, which uses the CustomerRepository to create the Customer object which needs a DatabaseConnection connection and passes a strategy (NameFormattingStrategy) to format the name of the customer to the Customer object and a CustomerDataMapper to allow the Customer object to save itself. Here are the constructor signatures of the involved components:

class Customer ...
    public function __construct(
        NameFormattingStrategy $nameFormattingStrategy
    )
class CustomerRepository ...
    public function __construct(
        DatabaseConnection $connection,
        CustomerDataMapper $dataMapper,
        NameFormattingStrategy $nameFormattingStrategy
    )
class CustomerServiceLayer ...
    public function __construct(CustomerRepository $repository)
class CustomerDataMapper ...
    public function __construct(DatabaseConnection $connection)
class DatabaseConnection ...
   public function __construct(
       string $host,
       int $port,
       string $username,
       string $password,
       string $database
    )

So, all we do in the page controller, may it be a (page) controller or a plain PHP file is instanciating the service layer and its dependencies:

$databaseConnection = new DatabaseConnection(...);
$customerDataMapper = new CustomerDataMapper($databaseConnection);
$nameFormattingStrategy = new NameFormattingStrategy();
$customerRepository = new CustomerRepository(
    $databaseConnection,
    $customerDataMapper,
    $nameFormattingStrategy
);
$serviceLayer = new CustomerServiceLayer($customerRepository);
$customer = $serviceLayer->getCustomerById((int)$_GET['customer_id]);
... pass it to the view, do nifty things ...

If other components, like the OrderRepository needs a database connection, just pass it to it. No need to let the order repository know how to get it. It is just there. In your unit test you can passed a mocked repository, a mocked database connection and a mocked data mapper depending on what particular part of the chain you are going to test. By the way: the heavy construction work could be easily passed to a number of factories just responsible for creating your objects. These factories are easily testable too as the only assertion made would be is the returned object correctly configured.

A Tech Book a Day

nospam@example.com (Lars Strojny) — Mon, 02 Feb 2009 18:50:14 +0100

When it comes to reading I’m coming from a different corner: I read a lot of philosophical books from philosophers like Adorno, Marcuse, Marx before I really started reading tech books. These books are hard to read, especially the works of the Frankfurt School are notorious for their specific language which is sometimes hard to decipher. Tech books are exactly the opposite: while there are entertaining technical writers with a good style a lot use a pretty common and dry vocabulary – which is a good thing. The thing is, you don’t really need to read tech books.

Novels, philosophical – and more general humanistic – works are much harder. They often transport semantics in metaphors you don’t get when just reading. You have to read a sentence more than once to get it. But when you read a book about Design Patterns, your favourite book on PHP or something similar non-algorithm related you can just scan the book for news, read and understand the code samples and go on, page per page. Scan through the page, take notes but just note what’s new to you. If it is a reference, mark the important parts with stickers. Ignore the rest, remember, don’t read, just scan.

Additionally technical books tend to have a foreword and a foreword for the second edition and a forward for the third edition and a lot of testimonials attesting how good this book is (hey, I already purchased it, don’t sell it to me again). So the real content starts at page 40. Excluding white pages the book that was 400 pages long might shrink to 300 pages. If you need 30 seconds per page that means you can read the book in two and a half hours. And 30 seconds per page a a pessimistic estimation. With this technique it is possible to read a technical book in a day without stress and totally relaxed in a week. That means you could read 52 tech books a year. I’m lame, I just ~~read~~ scanned around 20 last year.

Using IMAP semantics to control web publishing

nospam@example.com (Lars Strojny) — Sat, 10 Jan 2009 00:44:18 +0100

Every time a new comment or trackback arrives here I get a new mail. Of course I read mails over IMAP, as I utilize a number of different clients. It always felt a bit clumsy to click a link to decide what happens with the new comment: should it be approved or deleted? At the end I decide twice a time what happens with the comment. First I click the link for approval or deletion, second I decide what to do with the notification mail. Why not couple these options? Every unread comment mail represents a moderated comment, if I delete the mail, the comment is deleted, if I just mark the mail as read, it will be approved. The good thing is, we have IMAP so the blog comment moderation daemon would be just another IMAP client that watches a single mail directory. Wouldn’t that be cool? Maybe Garvin would like that for Serendipity.

Seven Things

nospam@example.com (Lars Strojny) — Sat, 03 Jan 2009 13:06:08 +0100

I’ve got tagged by Brian DeShong and Manuel Pichler to write down seven facts about me. Quick and easy:

Sung in a boys choir and had professional vocal training for almost ten years. We wore funny suits and it was quite cool
Sung the alto solo of the Paul McCartney opera Liverpool Oratorio. You didn’t even know Paul McCartney wrote operas, right?
Went to a Rudolf Steiner school for 13 years. This was not so cool as I’m not enough into mystery
I’m together with a upcoming geologist. I’m trying to get her into the oil business against her will. We actually met on a dating portal but I have an excuse: I worked there at that time.
I read most of the works of Theodor W. Adorno, the important ones from Karl Marx and it made me a better programmer. Not.
I still think smoking is one of the coolist habits ever.

So here are my nominated victims:

Johannes Steidl, my best friend, because I want to know if I guess right on what the facts are
Lukas Smith for his efforts in bringing more structure in the PHP core development process
Johannes Schlüter ‘cause I know he will hate it
Karsten Gohm a new collegue of mine
Marc Zacher, the guy who had an intimate affair with Bart
Marc Jakubowski because of stuff like that

Ubuntu Linux on an Asus EeePC 901

nospam@example.com (Lars Strojny) — Sun, 28 Dec 2008 18:43:36 +0100

I got an Asus EeePC for Christmas. As a long time Linux user the pre-installed Windows XP version had a very short life, something around ten minutes to check that the hardware is working. In general installing Linux is not very hard, actually the harder part was to build the install USB stick, as the EeePC has no disk drive. But first a few sentences about the EeePC.

The Good

The device is small and looks cute so the girl acceptance level is pretty high as my personal girl acceptance level test girl confirmed. It just feels right. The weight is alright, 1.1kg is fair enough. Three USB slots, one more than my Apple Mac Book, so good too. VGA out, fine, SD card slot, alright, not that I need it but … RaLink WiFi chip, Gigabit network, built-in web cam, Bluetooth, synaptics touch pad. That’s pretty good, sounds like a complete computer, doesn’t it? The display resolution is 1024×600 – good for such a small device.

The Bad

As as result of the overall size, the keyboard is of course small too. Also I’m now writing this entry on it, it takes some time to get used to it. The position of the pipe/less/greater-key is annoying as it can only be reached in combination with the fn modifier key. This is not very convenient for a programmer. The rest of the layout is more or less standard and it doesn’t take so long to not miss every key.

The Ugly

When I tried Bluetooth the first time, the device was not detected at all. Neither on Windows nor on Linux. But while changing other stuff I found out that the Bluetooth adapter was disabled in the BIOS. It is a nice feature to allow to hard disable some features in the BIOS but disabling anything by default seems not like the most clever idea. So please fix, Asus.
Sadly the EeePC suffers a heat problem. If you stress it a bit it gets really hot on the downside (like the Mac Books). So don’t put it on your naked thigh.

Choosing the Right Distribution

I have the model with two solid state discs which makes a total of 12GB disk space. Not very much but enough for my use cases (and I always wanted to have a SSD based device). I decided to go with Ubuntu:http://ubuntu.com also I normally prefer Gentoo because of the size. Source base distributions like Gentoo don’t differentiate between the actual packages and the header files so a complete Gentoo installations takes a lot more disk space than any binary distribution. Additionally, it was Christmas evening and I wanted something quick. While Gentoo is flexible, it is not quick to install.
Although I chose Ubuntu, I would roughly guess that Fedora or SuSE would work fine too, please leave a comment if you have an experience to share.
I chose Ubuntu mainline, not Eeebuntu because I want to have the latest and greatest Ubuntu and I can configure my panel myself.

Preparing the Installation

Before you read on further make sure you understand that this is not about a dual boot installation. I completely removed the Windows system, so please make sure this is what you want too.
First of all we need a boot medium. There is an SD card slot and a number of USB ports, so the alternatives are USB disk drive, SD card, USB stick. I chose the latter but the rest should work too. Creating an USB boot stick requires a bit of manual work: download the Ubuntu Intrepid Ibex (8.10) ISO image for 32bit computers (Atom CPU) then:

Format the stick with FAT32: mkfs.vfat /dev/sdX1
Add an MBR to the stick: cat /usr/share/syslinux/mbr.bin > /dev/sdX
Install syslinux: syslinux -s /dev/sdX1
Mount the ISO image: mount -o loop <iso> /mnt/iso
Mount the USB stick: mount /dev/sdX1 /mnt/stick
Copy the contents of the image to the stick: cp /mnt/iso/.* /mnt/stick
Fix the dists directory: mv /mnt/stick/dists/intrepid /mnt/stick/dists/stable
Rename isolinux directory to syslinux: mv /mnt/stick/syslinux /mnt/stick/isolinux
Rename isolinux.cfg to syslinux.cfg: mv /mnt/stick/isolinux/syslinux.cfg /mnt/stick/isolinux/isolinux.cfg

Installing Ubuntu from the Stick

Now the USB boot stick is ready. Just plug it in, type F1 to select the boot menu, choose the stick as the boot medium, boot from it and install Ubuntu as usual. Everything is detected and configured correctly including the synaptics touch pad, web cam and screen. The only missing components are the WiFi adapter and the specials keys. The keys generate ACPI events so it should not be hard to get them running. However, I don’t use specials keys so I don’t care.
The WiFi adapter is a RaLink RT2860 and RaLink provides a driver for it. You could download and manually compile this driver but I found it more convenient to have specific package for it.

Installing the Right Kernel

The linux-eeepc-lean kernel from array.org works really well and includes support for the RaLink WiFI adapter. Just follow the setup instructions to install it. Then boot the new kernel and, if everything works fine, edit /boot/grub/menu.lst to use the eeepc lean kernel as the default kernel. The Ubuntu installation is now done, enjoy!

SSH configuration parameters

nospam@example.com (Lars Strojny) — Tue, 14 Oct 2008 17:46:15 +0200

Having a number of hosts following the same naming scheme is good, defining them is repetitive and boring. Maybe we could patch SSH to achieve something like this. Take a look at an example for ssh-config:

Host myhost%02d
    User lars
    Hostname myhost$1.example.com

ssh myhost02 would be expanded and as a result would resolve to myhost02.example.com.

Antipattern: chaining stateless protocol requests

nospam@example.com (Lars Strojny) — Wed, 24 Sep 2008 20:55:13 +0200

As we all know, HTTP is a stateless protocol. We do all sort of hacks to add state, like ext/session in PHP. While such hacks work great for a lot of use cases, we should remind ourselves that they are hacks. There is a phenomenon of state creep: coupling unrelated HTTP requests. Think of a page that references a thumbnail in an <img/>-tag and the picture is generated as needed: it would be possible to generate that image in the context of the request that embeds that image. So the template calls a helper to generate the thumbnail and the thumbnail is generated in the file system.

While this works well for a single host, your personal weblog about cooking and cats, it won’t work for something serious. When you start load balancing between two webserver nodes you are set on fire as you can’t guarantee that the image is present on the correct node (beside you are generating the image n times where n is the number of nodes). The solution is not that hard: pregenerate all the images with a queuing system and display “This image is currently not available”-placeholders as long as they are not ready or – in case of little image uploads – generate them when uploading the image. The other option is to generate them on the fly when they are requested. If you do the latter, do it in the context of the request that tries to receive the image, not in the embedding context (the page that embeds the image). Generating on the fly means that you deliver your files through PHP or something similar: this is fine as long as you have an HTTP accelerator in place.

One of the systems that does it in the way described above is Drupal. I’ve implement MogileFS for image storage and retrieval for Drupal and let me say, it was not a pleasure.

On a side note: HTTP 1.1 allows resources to be fetched in parallel, which makes generating images in the wrong context even worse from a user experience point of view, as the page will not show up until each thumbnail is generated.

8 Hints out of Testing-Turmoil

nospam@example.com (Lars Strojny) — Fri, 19 Sep 2008 17:55:00 +0200

Have a continuous integration solution in place. Really. If you don’t, you just burn money by writing tests. I would go so far and say, if you don’t have continuous integration, you should stop writing unit tests and do click testing. Let your CI system generate API docs, high level docs, code coverage report, testdox and every statical analysis info you generate.
The definition of “tests pass” is “tests pass on the continous integration system”. “Works for me” has neither a place in the bugtracker nor everywhere else.
If you can’t test it, the architecture is most likely wrong (exceptions are sessions and caching related code which is generally hard to test). Testability should be your main concern when writing code. What’s the use of fast or wonderful looking code, if you can’t repeatable prove it is working?
Prefer method calls over annotations. A typo in setExpectedException will trigger a transparent error, while a typo in expectedException will lead to Obscure Test, and most likely a Mistery Guest.
Run the whole test harness twice. This will hellp to identify setup/teardown bugs. Create a random test suite to identify the hard to track mistakes.
Run your testsuite really often. We run it with 15 seconds delay every minute and I’m pretty happy with it.
Use good test names that describe the behavior of the unit. The behavior is not the unit you test itself, that’s what I see in the code, it is something like “calling register changes the status of the user to foobar” so the good test name would be “testRegisterChangesTheStatus …”.
Aim for 100% code coverage. 95% is nothing to be proud about, I can guarantee, the missing 5% will be the hardest part.

Recovering a software RAID

nospam@example.com (Lars Strojny) — Sat, 13 Sep 2008 03:17:22 +0200

The scenario: my RAID crashed because I’ve messed around with the partition table of one of the disks in there. This results in a RAID array not being able to assemble itself because the superblock of the messed up device is invalid. The trick is pretty easy: just recreate the whole RAID with mdadm. The existing metadata will not be overwritten, the current information is just replicated. I used to have a simple RAID1, but I’ve now recreated it as an incomplete RAID5 (--level=5, --raid-devices=2) as the missing disk is soon to be bought.

$ mdadm --create /dev/md0 --level=5 --raid-devices=2 /dev/<original> /dev/<crashed>

If you like to stick with a RAID1, and not doing the migration to RAID5 along the way, just use --level=1 instead. I’m not really sure if the order of the disks matter and I’m not brave enough to find it out.

Tomorrow I’m going to buy the next disk for the RAID to make sure the redundancy level is alright. Generally I’m pretty amazed that this kind of setup is so robust. Even me messing around with it can’t bring it down.