Heute habe ich mir eine Kata vorgenommen, und zwar FizzBuzz. Ich schreibe mein Golang immer noch extrem kurz und unleserlich. Solche Dinge wie r[v] = list[v] lösen ein schlechtes Gewissen bei mir aus, aber trotzdem bekommt ihr hier den Sourcecode ohne irgendwelche Verschönerungen. Wie bei einer Kata üblich kommt erst der Test, dann der Code:

fizzbuzz_test.go

package fizzbuzz

import (
    "testing"
)

func TestAnswer(t *testing.T) {
    actual := Answer([]int{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,60})
    expected := []interface{}{1,2,"fizz",4,"buzz","fizz",7,8,"fizz", "buzz",11,"fizz",13,14,"fizzbuzz","fizzbuzz"}
    for a := range(actual) {
        if actual[a] != expected[a] {
            error(t, "Wrong", expected[a], actual[a])
        }
    }
}
func error(t *testing.T, message string, expected interface{}, actual interface{}) {
    t.Errorf("%s: '%s' != '%s'", message, expected, actual)
}

fizzbuzz.go

package fizzbuzz

func Answer(list []int) []interface{} {
    r := make([]interface{}, len(list))
    for v := range(list) {
        switch {
            case list[v] % 3 == 0 && list[v] % 5 == 0:
                r[v] = "fizzbuzz"
            case list[v] % 3 == 0:
                r[v] = "fizz"
            case list[v] % 5 == 0:
                r[v] = "buzz"
            default:
                r[v] = list[v]
        }
    }
    return r
}

Nachdem ich die letzten Wochen einen Ganzkörperplan befolgt habe und damit Montags, Mittwochs und Freitags sowohl Kreuzheben als auch Kniebeugen als auch Klimmzüge gemacht habe, muss ich heute mein Training ausfallen lassen. Mein Rücken zieht, und zwar genau an der Ansatzstelle des Lattissimus. Wahrscheinlich werde ich auch am Mittwoch noch nicht wieder trainieren können.

Am Wochenende hatte ich auch noch einen Rückfall in die Kohlenhydrate. Das alles passt natürlich nicht so gut, denn eigentlich hatte ich mir was anderes vorgenommen. Aber jetzt zurück zum Thema:

Ich konnte mich nur minimal beim Kreuzheben steigern, von 80kg auf 85kg. Und in der letzten Woche habe ich in meinem Trainingslog gesehen, dass meine Wiederholungszahlen bei jedem Training weiter nach unten gingen: 18, 15, dann 12 und den letzten Wert erspare ich euch jetzt. Bei dem 4. Training musste ich dann auch die Kniebeugen weglassen.

Bei Leangains gibt es gerade einen Artikel mit einigen Gedanken zum Krafttraining und der erste Satz lautet:

The deadlift is poorly suited to a high training frequency. I’ve never derived any benefit from training the lift more than once per week; and even that is pushing it in terms of recovery if I’m squatting heavy within that same week. Generally speaking, I’ve had my best deadlift-sessions while training the no more than once every 8-12th day

Zu Deutsch: Öfter als 1x pro Woche Kreuzheben zu trainieren bringt gar nichts. Jedenfalls nicht ab einem gewissen Level. Ein Einsteiger kann mit leichten bis moderaten Gewichten auch mehrmals trainieren, aber ich denke, sobald man bei dem eigenen Körpergewicht angekommen ist, sollte man etwas mehr Regenerationszeit einplanen. Und das werde ich jetzt machen.

Mein Trainingsplan wird als nächstes wieder auf einen Splitplan gewechselt. Da ich demnächst in meinem Keller trainieren will, muss ich den Plan noch ein wenig anpassen und auf die erst nach und nach dazukommenden Geräte einstellen. Wie ich das mache, weiß ich noch nicht. Bis zum Ende des Monats trainiere ich noch im Fitnessstudio und muss ich mich nicht einschränken, also werde ich wieder auf meinen Plan mit einzelnen Einheiten für PUSH/PULL/Beine zurückwechseln.

Es mag offensichtlich sein, aber ich will es hier doch noch festhalten: Um ein Element an eine map anzuhängen, genügt eine Zuweisung.

package main

import (
    "fmt"
)

func main() {
    var m = map[string]string{"1":"eins"}
    m["2"] = "zwei"
    fmt.Println(m)
}

Diese kleine Programm gibt folgende Ausgabe:

map[1:eins 2:zwei]

Daraufhin habe ich diese kleine Testanwendung geschrieben, die eine map[string]string nimmt, ein Argument hinzufügt und anschliessend einen String ausgibt, in dem alle Inhalte der map sortiert enthalten sind.

package main

import (
    "fmt"
    "strings"
    "sort"
)

func gq(m map[string]string) string {
    ma := make([]string, len(m))
    i := 0
    for key,value := range(m) {
        ma[i] = key + "=" + value
        i++
    }
    sort.SortStrings(ma)
    query := strings.Join(ma, "&")
    return query
}

func main() {
    var m = map[string]string{"1":"eins", "acht":"8"}
    m["2"] = "zwei"
    query := gq(m)
    fmt.Printf("result: ?%s\n", query)
}

Und ja, brauche ich so für meine erste kleine Anwendung von golang.

Weiter geht’s. Diesmal mit der Erstellung einer MD5-Hashsumme. Diese Funktion brauchte ich für die Validierung einer API-Anfrage. Dort sollte neben der Argumentliste auch eine Hashsumme der Argumente plus einem geheimen Schlüssel übermittelt werden. Nach ein paar erfolglosen Versuchen, aus der Package Documentation schlau zu werden, half mir (wieder einmal) Stackoverflow weiter.

Das ist übrigens auch der schwierigste Teil von Golang bis jetzt: Herausfinden, welche Funktion man aus einem Package gerade benötigt und vor allem wie man sie aufruft.

package main

import (
    "fmt"
    "crypto/md5"
    "hash"
)

func main() {
    original := "my string comes here"
    var h hash.Hash = md5.New()
    h.Write([]byte(original))
    fmt.Printf("%s: %x\n", original, h.Sum())
}

Gestern habe ich weiter an meiner ersten Applikation in golang gearbeitet und dabei stellte sich mir die Frage, wie man eine map[string]string sortiert. Stackoverflow hat (wie immer) weiter geholfen, nachdem ich ein paar Versuche selbst unternommen hatte.

Ich denke, die folgende Lösung ist nicht das schickste. Sicherlich gibt es eine nette Möglichkeit, eine map auch mit Channels zu sortieren. Ein BubbleSort sollte damit schnell erstellt sein. Das werde ich beim nächsten Mal ausprobieren.

package main

import (
    "fmt"
    "sort"
)

func main() {
    m := map[string]string{"b":"15", "z":"123123", "x":"sdf", "a":"12"}
    mk := make([]string, len(m))
    i := 0
    for k, _ := range m {
        mk[i] = k
        i++
    }
    sort.SortStrings(mk)
    fmt.Println(mk)
}

Ich bin in den letzten Tagen wieder öfter auf Go gestossen, Googles neue Programmiersprache. Und jetzt habe ich beschlossen, das ganze auch auszuprobieren – obwohl mir die Syntax erstmal nicht gefällt. Zu nah an C, zu viele Pointer… Aber trotzdem bin ich an neuen Inputs in Sachen Softwareentwicklung interessiert und gerade die Ausrichtung auf Mehrprozessorsysteme und message-basierte Anwendungen hat eine große Anziehungskraft. Also richte ich mir eine kleine Linux-VM ein und installiere alle notwendigen Pakete für Go (und ab jetzt werde ich mit golang auf die Sprache verweisen, denn 2 Buchstaben sind einfach zu wenig für eine Suchmaschine…).

Mercurial

Als erstes wird Mercurial installiert, da ich auf die neuste Version von Golang zugreifen möchte. Unter Debian geht das mit folgendem Kommando:

$ apt-get install mercurial

Golang

Seltsamerweise konnte ich nicht zu 100% der offiziellen Installationsanleitung folgen. Meine Installation von Mercurial wollte das Repository partout nicht über HTTPS klonen. Aber Google Code liefert das Golang-Repository auch über HTTP und damit bin ich schliesslich zum Ziel gekommen:

$ export GOROOT=/pfad/zu/go # Standard ist $HOME/go
$ export GOARCH=386
$ export GOOS=linux
$ hg clone -r release http://go.googlecode.com/hg/ $GOROOT

Um Golang selbst zu bauen, müssen noch ein paar Tools der GCC Toolchain installiert werden:

$ apt-get install bison gcc libc6-dev ed gawk make

Da ich zum Zeitpunkt der Installation hinter einem Proxy sass, musste ich die Testcases für die Pakete http und net in der Datei $GOROOT/src/pkg/Makefile deaktivieren:

NOTEST = \ # nach dieser Zeile einfügen
    http\
    net\
    ... # hier geht das Original weiter

Anschliessend kann muss das Zielverzeichnis für die Binaries erstellt und Golang gebaut werden:

$ mkdir $HOME/bin # Standardverzeichnis, umzusetzen über $GOBIN
$ cd $GOROOT/src
$ ./all.bash

Wenn alles glatt geht, dann sollte folgende Ausgabe kommen:

--- cd ../test
0 known bugs; 0 unexpected bugs

Hallo Welt

Jetzt folgt das erste Programm, in schöner Tradition natürlich ein Hello World. Einfach den Lieblingseditor starten und folgenden Text eingeben:

package main

import fmt 'fmt'  // Package implementing formatted I/O.

func main() {
    fmt.Printf('Hello, World!')
}

Anschliessend wird das Programm kompiliert:

$ ~/bin/8g helloworld.go
$ ~/bin/8l helloworld.8
$ ./8.out
Hello, World!

Ich folge dem Herdentrieb. Naja, eigentlich nur Markus. Aber sein Artikel tauchte gerade im Feedreader auf, deshalb mach ich einfach bei diesem Stöckchen mit.

• Wo ist Dein Handy? – Hosentasche
• Deine Partnerin? – unglaublich
• Deine Haare? – kurz
• Deine Mama? – immer beschäftigt
• Dein Papa? – Flieger
• Lieblingsgegenstand? – Iphone
• Dein Traum von letzter Nacht? – vergessen
• Dein Lieblingsgetränk? – Kaffee
• Dein Traumauto? – Metronom (Ja, ist ein Zug, schon gut…)
• Der Raum, in dem Du Dich befindest? – Büro (für noch 3 Wochen )
• Deine Ex? – unwichtig
• Deine Angst? – Hunde
• Was möchtest Du in 10 Jahren sein? – gesund
• Mit wem verbrachtest Du den gestrigen Abend? – mit meinem Macbook
• Was bist Du nicht? – nachtragend
• Das letzte was Du getan hast? – Trainiert
• Was trägst Du? – das übliche
• Dein Lieblingsbuch? – EINS?
• Das letzte, was Du gegessen hast? – Proteinshake+Müsli
• Dein Leben? – unruhig (bis nächsten Monat)
• Deine Stimmung? – ruhig
• Deine Freunde? – weit weg
• Woran denkst Du gerade? – an Stöckchen
• Was machst Du gerade? – schreiben
• Dein Sommer? – Probezeit
• Was läuft in Deinem TV? – Konsolenspiele
• Wann hast Du das letzte Mal gelacht? – gestern
• Das letzte Mal geweint? – Januar
• Schule? – (fast) vergessen
• Was hörst Du gerade? –meine Kollegen
• Liebste Wochenendbeschäftigung? – rumhängen
• Traumjob? – Softwareentwickler
• Dein Computer? – Macbook!
• Außerhalb Deines Fensters? – Sonne
• Bier? – nie
• Mexikanisches Essen? – klar!
• Winter? – schön
• Religion? – überflüssig
• Urlaub? – später
• Auf Deinem Bett? – Bücher
• Liebe? – ja

Es ist mal wieder soweit: Nach ein paar eher schlechten Wochen mit vielen Kohlenhydraten, muss ich heute meine Ernährung wieder neustarten. Los geht’s mit ein paar Tagen konsequentem low carb. Das heißt: unter 60g. In der letzten Zeit habe ich immer öfter Süsskram gegessen, hab meine täglichen Kalorienmenge nicht eingehalten und rund ums Training schlecht gegessen. Damit ist jetzt wieder schluss!

Ab sofort führe ich wieder Ernährungstagebuch. Ab sofort bleibe ich in meinem gesetzten Kalorienlimit. Ab sofort trainiere ich wieder anständig.

Auch wenn der Umzug gerade an meiner Konsequenz und meiner Sturheit nagt, werde ich das jetzt nicht weiter schleifen lassen. Meine nächsten Ziele sind:

• Bis Ende April: die überflüssigen 2kg loswerden
• Bis Ende Juni: 100kg Kreuzheben

Update: Und hier kommt noch mein aktueller Trainingsplan, bis Ende März ist das ein Ganzkörperplan:

• Kreuzheben
• Bankdrücken Schräg (Maschine)
• Kniebeugen
• Klimmzüge
• Dips
• Seitheben
• Bizep Curls (Kabel)

Wieso? Weil ich immer noch großer Fan von eMail bin. Asynchrone Kommunikation, trotzdem Quasi-Echtzeit und kostenlos. Und weil ich auf meine eMail von überall Zugriff habe, Iphone sei Dank.

Nachdem ich schon den Service FeedMyInbox ausprobiert habe und mit dem Amazon Kindle einen sinnvollen Endpunkt für so einen Dienst in meiner Reisetasche habe, wollte ich mal sehen, ob ich das ganze nicht auch auf meinen eigenen Rechnern und damit unter meiner Kontrolle aufsetzen kann. Gesagt, getan: rss2email erledigt genau diese Aufgabe.

Unter Debian ist das Programm schnell installiert:

apt-get install rss2email

Voraussetzung ist Python, aber das ist mittlerweile ja schon fast Pflicht bei einer Linuxinstallation… :-} Danach kann man mit folgenden Befehlen die ersten Feeds hinzufügen:

r2e new email@domain.org
r2e add http://url/fuer/den/feed
r2e run --no-send

Damit ist der erste Feed hinzugefügt und der erste Lauf hat den aktuellen Stand des Feeds geholt. Der Parameter --no-send verhindert das Versenden aller Feedartikel, erst bei einem Aufruf ohne diesen Parameter werden eMails verschickt. Das sollte man aber einem cronjob überlassen, der zyklisch läuft. Bei mir ist das alle 30 Minuten:

crontab -l
*/30 * * * * r2e run

Ab sofort fliessen also einige Feeds direkt in mein Postfach. Ob ich wirklich die Gebühren für die Mobilfunkübertragung zum Amazon Kindle bezahlen will, weiß ich noch nicht. Möglich wäre das ganze aber mit rss2email, dafür müsste ich bloss eine neue Feeddatei mit meiner privaten Kindle-eMail anlegen und Feeds hinzufügen.