Wer hat denn solche Beine!?

Ich glaub’s nicht! Seit Tagen versuche ich, eine Jeans zu finden, die mir passt. Irgendwie werden mir meine Hosen allesamt zu klein an den Oberschenkeln. Dabei hab ich gerade mal 61cm Umfang, das ist nicht mal viel!

Und trotzdem passt keine einzige Hose!

Ich werd mal anfangen, in den Kraftsportläden rumzugucken… kann doch echt nicht sein. Demnächst muss ich noch Hosen tragen wie der hier.

Was macht den guten Programmierer aus?

Ich lese ja öfter mal auf Programmers StackExchange und dort findet man einige Perlen:

Eine Antwort auf die letzte Frage war

Programmers who don’t code in their spare time for fun will never
become as good as those that do.

Das ist auch meine Meinung.

Damit will ich nicht sagen, dass alle Entwickler keine Freizeit, kein Leben und keine anderen Interessen haben
sollen. Ãܜberhaupt nicht. Aber für mich ist das eine Frage des inneren Antriebs:

Wenn ich mich für ein Thema interessiere, dann will ich immer mehr und immer neue Dinge darüber erfahren.

Und das funktioniert nicht im Büro von 9 bis 17 Uhr (eh ja, ok: von 7 Uhr – ich bin halt Frühaufsteher). Da muss
man nämlich ganz konkrete Probleme lösen und ist in den Mitteln zur Problemlösung oft durch die vorhandene
Infrastruktur, die Lizenzen, die Hierarchie eingeschränkt. Und wenn ich mir die Grundideen der funktionalen Programmierung mit Clojure,
eine komplette Deploymentpipeline für Continuous Deployment oder einfach
eine neue Programmiersprache wie Googles Golang angucken möchte, dann kann ich das nicht unbedingt während
meiner Arbeitszeit im gerade laufenden Projekt tun.

Und ich bin auch der Meinung, dass man als guter Softwareentwickler Unmengen an Büchern lesen muss. Nicht, weil
Lesen so entspannend ist (jedenfalls nicht nur), sondern weil man aus Büchern auf einen Schlag eine Menge Input
bekommen kann und diesen in Zukunft vielleicht auf eine neue Problemlösung anwenden kann. Und selbst wenn ich
nicht alles immer zu 100% verwerten kann und damit mein aktuelles Projekt im Büro voranbringe, dann hilft es
mir, einen anderen Blickwinkel auf meine Arbeit zu bekommen.

Und für mich persönlich kann ich sagen, dass ich meinen Job in der Softwareentwicklung nicht gewählt habe, um
Karriere zu machen und/oder viel Geld zu verdienen. Ich finde, dass die Tätigkeit der Softwareentwicklung eine
sehr spannende Aufgabe ist und ich möchte jeden Tag auf’s neue Probleme finden und lösen.

Weil ich das so spannend finde, kann ich auch zuhause nicht aufhören, an kleinen Privatprojekten rumzubasteln,
neue Programmiersprachen auszuprobieren oder einfach eine kleine Unannehmlichkeit für mich selbst zu lösen.

Aber das sehe ich für jeden Beruf so. Völlig egal, ob man Softwareentwickler ist oder in Wales Schafe züchtet und Olympiasieger im Hütehundsport werden will.

Und ja, StackExchange lesen ist für mich Weiterbildung. 😉

Kein Motorradwetter

Eigentlich wollte ich ja am Sonntag mit dem Mädchenfahrrad Richtung Norden zurückfahren – aber die aktuellen Temperaturen und Witterungsverhältnisse haben anderes vor. Ich werd also noch 4 Wochen warten müssen, bis ich die norddeutschen Strassen auf zwei Reifen abnutzen kann.

Na, ich bin dann doch mit dem Motorrad gefahren. Die Temperaturen waren gut, die Sonne schien. Ich hab mich natürlich vor Neustadt a. Rbg. verfahren und eine kleine Besichtigungstour durch die Dörfer gemacht – nächstes Mal sollte ich das GPS mitlaufen lassen. Oder mir gleich eine Tasche für mein Handy organisieren, so dass ich das auf dem Tank festmachen und mitlaufen lassen kann.

Wie auch immer, jetzt steht das Motorrad hier vor der Tür und wartet auf ein paar Ausritte. 🙂

Wie man Pluspunkte in der Entwickler-Community sammelt

Ich bastel ja seit ein paar Tagen an einem Clojure-Client für die neue Fitbit API, mit der man an die Daten auf www.fitbit.com herankommt. Dabei viel (nicht nur) mir auf, dass OAuth seit ein paar Tagen 404-Fehler wirft und ich mich nicht mehr mit meinem Applikation-Token und -Secret anmelden kann.

Erst war ein paar Tage Funkstille im Entwicklerforum, aber dann meldete sich endlich ein Offizieller mit einer Erklärung:

We’ve been working hard to improve the Fitbit developer APIs. Lately, we’ve noticed a number of wrinkles with the authorization system, and we have a few fixes that are scheduled to be rolled out tomorrow. Most of these issues have been noticed first by the Fitbit developer community.
[…]
If you’re still having issues, it would help us immensely if you could submit a Minimal Reproducible Test Case.
[…]
We’ll keep working to resolve any issue, no matter how it’s reported, but sending a Minimal Reproducible Test Case with help us investigate your issue much more quickly! Plus, you get the assurance of knowing that we’ll be adding your specific test case to our release testing process.

Damit wurde die Funkstille zumindest bei mir wieder etwas gutgemacht. Ich finde es grundsätzlich positiv, wenn die Verantwortlichen auf die externen Entwickler hören, die mit einer neuen Funktion herumspielen und versuchen, damit etwas eigenes aufzubauen. Wenn man dann noch merkt, dass man der Firma hilft, Probleme aufzudecken und sogar in Zukunft zu vermeiden, dann ist das für mich auch ein Erfolgserlebnis.

Und wenn ich demnächst ohne 404s weitermachen kann, dann werd ich bald auch mit dem Clojure-Client fertig und kann mich wieder der ursprünglichen Idee, nämlich einem Google Docs/CSV-Export auf der Google Appengine widmen. 🙂

iX kompakt 1/2011 zum Thema Softwarequalität

Es gibt ein iX Sonderheft zum Thema Softwarequalität. Das solltet ihr euch alle mal kaufen und auch lesen. (Wer ISTQB-zertifiziert ist, wird viele bekannte Namen und Artikel finden, aber es lohnt sich trotzdem).

Bei kaum einem anderen Produkt lässt
sich Qualität so schwer beurteilen
und herstellen wie bei Software. Neben
augenfälligen Dingen wie guter Bedienerführung
spielen zahlreiche andere Faktoren eine
Rolle. Die Schwierigkeiten sind so groߟ,
dass die Menschheit gelernt hat, mit
schlechten Kompromissen zu leben.

via iX-kompakt-1-2011-Softwarequalitaet.

Interessante Artikel über die Architektur von StackOverflow

Wer sich für StackOverflow interessiert und etwas über die Architektur und die Technologie wissen möchte, der findet in den folgenden Seiten interessante Informationen:

Wenn’s noch weitere gute Links gibt, schreibt einen Kommentar oder meldet euch per Twitter.

    Arbeitgeber und -nehmer

    Fefe hat heute noch was zu den Begriffen Arbeitgeber und Arbeitnehmer geschrieben und dabei auf das Vorwort von “Das Kapital” von Karl Marx verwiesen. Hier ist der entsprechende Absatz:

    Es konnte mir nicht in den Sinn kommen, in das „Kapital“ den landläufigen Jargon einzuführen, in welchem deutsche Ökonomen sich auszudrücken pflegen, jenes Kauderwelsch, worin z.B. derjenige, der sich für bare Zahlung von andern ihre Arbeit geben läßt, der Arbeitgeber heißt, und Arbeitnehmer derjenige, dessen Arbeit ihm für Lohn abgenommen wird.

    via Das Kapital – Zur dritten Auflage.

    In Alternativlos 13 war ja die Rede davon, wie solches Neusprech immer wieder zu seiner Bedeutung zurückfindet, aber diese beiden Beispiele sind noch im Umlauf und anscheinend auch in der ursprünglichen Bedeutung erhalten.

    Destructuring von Parametern in Clojure

    In Clojure gibt es ein nettes Sprachmittel, um Parameter -oder generell: Elemente aus Listen- herauszuholen. Am häufigsten wird das sicher bei Funktionsparametern eingesetzt. Hier ist ein einfaches Beispiel:

    ;; Anlegen einer Koordinate
    (def coord [3 5])
    ;; Ausgeben der Koordinaten
    (let [[x y] coord]
      (println"x:" x"y:" y))
    

    Zeile 2 legt eine Koordinate an, bestehend aus 2 Zahlen. Zeile 4+5 destructures die Koordinate und weist den Parametern x und y die Werte aus coord zu. In der Funktion werden die Parameter dann verwendet und als String ausgegeben.

    Den gleichen Mechanismus nutzt man eigentlich bei jeder Funktion. Am deutlichsten wurde mir das, als ich das obige Beispiel für beliebig-dimensionale Koordinaten erweitert habe:

    ;; 3-dimensionale Koordinate anlegen
    (def coord [1 2 3])
    ;; Koordinate ausgeben
    (let [[x y& more] coord]
      (println"x:" x"y:" y"others:" more))
    ;; => x: 1 y: 2 others: (3)
    

    Jetzt werden immer noch die ersten beiden Elemente aus der Koordinate geholt, aber der Rest wird durch & more als Liste weitergegeben. Diesen Mechanismus nutzt man oft bei der definition von eigenen Funktionen in Clojure.

    Foundation, Folge 3 mit Philip Rosedale

    Wer den Namen nicht kennt, der Typ hat Second Life gebaut.

    Darum geht’s aber in diesem Video gar nicht, sondern um die Entwicklungsprozesse in seinen Firmen. Ab Minute 20 fängt richtig interessantes Zeug an, über kollaborative Entwicklung, über Bid-Systeme in der Softwareentwicklung, über positives Feedback, über Open Work Spaces… ach, schaut’s euch einfach selbst an:

    Foundation 03 // Philip Rosedale von Kevin Rose auf Vimeo

    Ach, ich darf mir sowas gar nicht angucken. Da sind so viele tolle Ideen drin, dass ich aus dem fantasieren gar nicht mehr rauskomme. Schon die ersten 20 Minuten waren interessant und ich hab ein paar Mal echt laut gelacht. 🙂 Foundation könnt ihr euch direkt in den Podcast-Downloader kopieren, die Videos sind immer sehenswert.

    Unit Tests in Clojure (und Leiningen)

    Damit es hier nicht zu weichspülerartig mit Videos weiter geht, kommt noch was für die Clojure-Leute. 🙂 Ich will langsam mit den Unit Tests für Clojure anfangen und hab dazu 3 sehr einfache Funktionen definiert. Dazu eine Datei mit einigen einfachen Unit Tests. Das ganze kann man mit Leiningen sehr einfach ausführen:

    $ lein test
    Testing clj-testtest.test.core
    Ran 7 tests containing 7 assertions.
    0 failures, 0 errors.
    

    Hier ist der Code:

    src/core.clj

    (ns clj-testtest.core)
    
    (defn foo
      [a b] (str a":" b))
    
    (defmacro mfoo
      [a b] `(str ~a":" ~b))
    
    (defn gen-foo
      [a b c] (defn a [b c] (str b":" c)))
    

    test/core.clj

    (ns clj-testtest.test.core
      (:use [clj-testtest.core] :reload)
      (:use [clojure.test]))
    
    (deftest test-simple
      (is (not (= 5 (+ 2 2)))))
    
    (deftest test-foo
      (is (="a:b" (foo 'a 'b))))
    (deftest test-foo-numbers
      (is (="5:7" (foo 5 7))))
    (deftest test-foo-strings
      (is (="eins:zwei" (foo"eins""zwei"))))
    (deftest test-foo-broken
      (is (not (="eins:zwei" (foo"eins" 7)))))
    
    (deftest test-mfoo
      (is (="a:b" (mfoo 'a 'b))))
    
    (deftest test-genfoo
      (is (= (foo 'a 'b) ((gen-foo 'foo 'a 'b) 'a 'b))))
    

    Die Funktion test-simple in Zeile 5 hab ich nur zum Test eingebaut, weil ich mir erst nicht sicher war, wie sich die Unit Tests verhalten. Aber nachdem ich die ersten Unsicherheiten mit (is (not (usw usf))) überwunden hatte, war der Rest ein Kinderspiel… oder so ähnlich. 🙂

    Der interessante Test ist in Zeile 21 zu sehen: Ich teste, ob die Funktion gen-foo eine Funktion zurückgibt, die eine Ausgabe identisch zur vorher definierten und getesten Funktion foo liefert.

    Und es klappt. Jetzt: Bett. 😉

    PS: Alle Quelltexte könnt ihr als Gist runterladen oder clonen.

    PPS: Ausserdem gibt es jetzt ein ganzes Repository mit meinen Beispielen zu Unit Tests in Clojure.