Zen Mind, Beginners Mind

Meine neue Lektüre, tatsächlich auf Papier. Leider gab es das Buch nicht im Kindle Store, daher hab ich es auf www.tauschticket.de rausgefischt.

Zen Mind, Beginners Mind, ursprünglich hochgeladen von cringe

Update: Ich hab mir auch die deutsche Version geholt:

Learning Golang #4, oder FizzBuzz Kata

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
}

Learning Golang #3, oder Wie hänge ich ein Element an eine Map?

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: ?%sn", query)
}

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

Learning Golang #1, oder Wie sortiere ich eine map?

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)
}

Learning Golang #2, oder Wie erstelle ich eine MD5-Hashsumme?

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: %xn", original, h.Sum())
}

golang: Erste Schritte

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

Update Mittlerweile liegen die Sourcen in einem Git Repository.

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!