Zurück aus Wacken. Es war einfach großartig. Wenn alles klappt, bin ich nächstes Jahr wieder da.

The Case Against KotlinKotlin ist eine schicke Sprache aber halt noch neu. Bis das Tooling etc. auf dem Stand von beispielsweise Java ist, wird es noch ein wenig dauern. Das muss man selbstverständlich berücksichtigen.

Toward dumber — Das stört mich an den reichweitenorientierten (Werbung verkaufenden) Medien schon länger.

And then someone comes along who figures out how to take your version of dumbness and go further than you were willing to go.

Endlich Zeit gehabt nachzuschauen, wie unter xUnit auf Exceptions getestet wird.

Silex is dead (or not) — Silex war immer irgendwie das Stiefkind zu Symfony, fast aber nicht ganz kompatibel und immer ein bisschen hinterher. Ich freue mich schon auf Symfony 4 und Lumen ist auch eine gute Alternative.

HTTP Tools Roundup — Nützliche Helferlein für den Umgang mit HTTP-APIs. jq hat mir schon einiges an Nerven gespart.

Textverarbeitungen machen mich fertig. Irgend etwas an WYSIWIG funktioniert exakt entgegen meiner Denkweise.

Ich brauche dringend ein Headerbild.

Gedanken zur WordPress Codebasis

WordPress Core ist nicht schrecklich. WordPress Core ist nicht modern und nicht schön.

Allerdings ist WordPress Core gut dokumentiert und konsistent.

Da kann ich ganz gut mit leben.

Bei Plugins oder Themes sieht das allerdings wieder ganz anders aus.

Zu einem Software-Ökosystem gehören auch die Menschen. Und die finde ich bei WordPress ziemlich super.

UTF8 VS UTF8MB4 – What’s the difference? — Es ist leicht, sich darüber lustig zu machen, dass die MySQL-Entwickler damals nur drei Byte für UTF-8 vorgesehen haben. Aber es hieß auch mal 65535 Zeichen würden für Unicode ausreichen. (Spoiler: Taten sie nicht.)

Unit Testing in .Net Core sieht irgendwie komplizierter aus als es sein sollte.

Leichter Besuchen mit Lambdas

Ich verbessere gerade mein C# und schaue daher eine Menge YouTube-Videos. Eine schöne Methode einen Visitor zu implementieren habe ich in Using C#’s Type System Effectively gefunden: Die Funktionen für die verschiedenen Knotentypen werden einfach als Lambdas übergeben.

Grundlage ist beispielsweise folgende Klassenstruktur:

public abstract class Expression
{
    public abstract T Visit<T>(
        Func<bool, T> literal,
        Func<Expression, Expression, T> and);
}
 
public class AndExpression : Expression
{
    public AndExpression(Expression left, Expression right)
    {
        Left = left;
        Right = right;
    }
 
    public Expression Left { get; }
    public Expression Right { get; }
    public override T Visit<T>(
        Func<bool, T> literal,
        Func<Expression, Expression, T> and) => and(Left, Right);
    }
}
 
public class LiteralExpression : Expression
{
    public LiteralExpression(bool value)
    {
        Value = value;
    }
 
    public bool Value { get; }
 
    public override T Visit<T>(
        Func<bool, T> literal,
        Func<Expression, Expression, T> and) => literal(Value);
    }
}

Jetzt kann ich mit folgender Funktion den Ausdruck in einen String umwandeln:

static string ToString(Expression expr) => expr.Visit<string>(
    literal: (value) => value ? "TRUE" : "FALSE",
    and: (left, right) => ToString(left) + " and " + ToString(right)
);

Oder ganz einfach auswerten:

static bool Evaluate(Expression expr) => expr.Visit<bool>(
    literal: (value) => value,
    and: (left, right) => Evaluate(left) && Evaluate(right)
);

Mir gefällt die Lösung sehr, da sie typsicher ist (wenn ich einen Knotentyp hinzufüge, muss ich Visit überall anpassen) und einfache Transformationen einfach in einer Funktion geschrieben können.

Definitiv besser als Java. 🙂

Update

Es sind natürlich nicht die Lambda-Ausdrücke, die das so möglich machen sondern die benannten Argumente. Sorry. Trotzdem besser als Java.

Habe in der Mittagspause ein wenig Ruby-Code geschrieben. Es war wie mal wieder in einen lange verloren geglaubten Lieblingspulli zu schlüpfen: Etwas kratzig, aber von Anfang an ein gutes Gefühl. 😀

Als nächstes werde ich wohl Webmentions einrichten. Plugins gibt es ja dafür.

Processing ist ein tolles Beispiel dafür, wie man schicke Sachen einfach mit Java tun kann. Und es macht Spaß.

Morgengedanke: Java ist eigentlich eine feine, kleine Programmiersprache. Es ist das EE-Ökosystem was einigermaßen schrecklich ist.

Das wasserlose Klo. Nicht nur wegen der Technik interessant, sondern auch weil erklärt wird was es alles braucht um unser (für uns) unspektakuläres Wasserklosett möglich zu machen.

JSON Feed ist genau was der Name sagt: Ein Newsfeed in JSON. Leicht zu erzeugen, leicht zu parsen. Ich hoffe mal, dass das Format populär wird.

Steve Yegge über Kotlin. Ich laufe ja nicht (mehr) jedem Hype hinterher, aber nach diesem Artikel werde ich mir die Sprache definitiv anschauen.

Ich schreibe zur Zeit nicht viel weil ich meine ganze freie Zeit mit TADS verbringe. Liegt mir mehr als Inform 7, nicht nur weil das Tooling so schön archaisch ist.

Dinge die ich mir wirklich angewöhnen will, Teil 238: rmdir anstelle von rm -r nutzen, wenn ich mir sicher bin, dass das Verzeichnis leer ist. #unix #devops

Eine aktuelle Sammlung aller Hosts/Accounts und Berechtigungen erstellen. Aus der Abteilung: Dinge die keinen Spaß machen aber öfter getan werden sollten. (Siehe auch: Unkraut jäten, Backofen reinigen.)