Buchtipp: "A Language a Day - A brief introduction to 21 programming languages

Danke, werde ich mir besorgen und bei Gelegenheit durch lesen

Dennis89 21 Programmiersprachen .. das Jahr hat 52 Wochen ... dann kannst Du Dich ja in jeweils 2 Wochen in eine weitere Programmiersprache einarbeiten - SCNR

Ja perfekt, das bisschen programmieren kann ja nicht so schwer sein

Der Buchtitel ist ja so ein bisschen eine Kampfansage an Norvig's Essay Teach Yourself Programming in Ten Years. Deutsche Übersetzung: Lernen Sie programmieren in zehn Jahren!

Musste spontan an „Seven Languages in Seven Weeks“, „Seven More Languages in Seven Weeks“, und „Seven Obscure Languages in Seven Weeks“ denken.

Okay, Feedback zu C++: Es wird nicht erwähnt, dass man sich bei der Sprache um die Speicherverwaltung kümmern muss — egal was verstrahlte C++-Fans behaupten — und das Zoo-Beispiel dann auch gleich mal Hunde und Katzen im Speicher aussetzt → der Speicher wird nicht freigegeben.

In modernem C++ verwendet man keine normalen Pointer mehr, da würde das dann beispielsweise so aussehen:

#include <iostream>
#include <string>
#include <vector>
#include <memory>  // Neu.

using namespace std;

class Animal {
public:
    virtual string info() = 0;
    virtual ~Animal() {};  // Neu.
};


class Cat: public Animal {
public:
    virtual string info() {
        return "Cat";
    }
};


class Dog: public Animal {
public:
    virtual string info() {
        return "Dog";
    }
};


int main() {
    vector<unique_ptr<Animal>> zoo;  // Geändert.
    zoo.push_back(make_unique<Cat>());  // Initializer list geht nicht,
    zoo.push_back(make_unique<Cat>());  // darum push_back().
    zoo.push_back(make_unique<Dog>());
    zoo.push_back(make_unique<Dog>());
    for (auto& x : zoo) cout << x->info() << "\n";
}

Was dann wohl zusätzlich hätte erklärt werden müssen wären Destruktoren, Smart-Pointer, „Move“-Semantik, und Referenzen. C++ ist halt eklig kompliziert.

Mich hätte auch interessiert nach welchen Kriterien die behandelten Sprachen gewählt wurden. U.a. sind ja auch drei JVM-Sprachen dabei.

Ich komme bisher leider nicht darüber hinaus mit bspw. C/C++ reale Anwendungen zu entwickeln, sondern hänge immer an den bekannten Lektüren aus den 70er und 80er (The C Programming Language, A Tour of C++) fest. Auch wenn es insgesamt spaß macht und mir als Lehrsprache für Low-Level-Zeug taugt, ist der Frustrationsgrad manchmal enorm. Gerade bei C.

noisefloor Die Frage warum Sprache X (nicht) aufgenommen wurde, kann man ja eigentlich für jedes X stellen. C++ ist eine verbreite Sprache und modernes C++ sieht anders aus als ”traditionelle(re)s” C++, also ist das auch für Leute interessant, die C++ schon mal gelernt haben.

Halbwegs idiomatischen und fehlerfreien Code würde ich von so einem Buch aber schon erwarten. Vier Beispiele für „Hallo, Welt!“, Fakultät (Rekursion), Polymorphie, und Nebenläufigkeit in n Sprachen, die aber alle nur verkleidete ”Übersetzungen” von Sprache X sind, fänd ich als Buch eher nicht so spannend. Das man FORTRAN in jeder Sprache schreiben kann, wüsste ich auch ohne ein zusätzliches Buch. 😉

Kann sein, dass das Beispiel dann zu lang geworden wäre, aber wenn die Sprache nun mal diese Komplexität hat, dann macht das ja auch irgendwie keinen Sinn dem Leser das vorzuenthalten.

Hm, bei C++ fehlt die Fakultät.

Beim Kapitel „Hy“ fällt als erstes auf, dass IMHO ohne sinnvollen Grund per pip von Github installiert wird, statt ein normales Release von PyPI. Was nicht installiert wird ist hyrule — die Standardbibliothek von Hy.

Dann kommt mir da zu viel Python drin vor. Wenn man ein Programm erst in Python vorschreibt, dann schreibt man ja am Ende kein Hy-Programm, sondern ein Python-Programm in Hy-Syntax.

Die Fakultät kann man einfacher haben statt sie selbst zu implementieren:

(import math [factorial])
(print (factorial 1))
(print (factorial 5))
(print (factorial 7))

Beim ersten Klassenbeispiel bietet sich das meth-Makro an um sich Code zu sparen. Und entweder nennt man die Methode get-info oder bleibt bei dem Namen info und macht ein Property daraus.

#!/usr/bin/env hy
(import hyrule *)
(require hyrule *)

(defclass Person []
  (meth __init__ [@name @age])
  (meth [property] info [] f"{@name} is {@age} y.o."))

(defmain []
  (setv john (Person "John" 30))
  (print john.info)
  (setv alla (Person "Alla" 20))
  (print alla.info))

Die erste Sleep-Sort-Variante ist das Schlafen für 2 Sekunden unsinnig. Das braucht man nicht, die Timer-Threads halten das Programm am leben bis der letzte davon am Ende angekommen ist. Falls dem nicht so wäre, dann wäre das sleep am Ende falsch, denn dann würde man auf das Ende der Threads mit join warten müssen, wie im C++-Beispiel. Und genau wie im C++-Beispiel braucht man ein Lock um das threadsicher zu machen. Und zwar auch wenn da am Ende CPython mit dem GIL hinter steht, denn wenn man die Verzögerung weit genug runter schraubt, bekommt man keine sortierten Ausgaben mehr!

#!/usr/bin/env hy
(import hyrule *)
(require hyrule *)
(import threading [Lock Timer])

(defmain []
  (setv data [10 4 2 6 5 7 1 3]
        lock (Lock))
  (for [n data]
    (doto (Timer (/ n 1000)
                 (fn [n] (with [lock] (print n)))
                 [n])
          (.start))))

Nebenläufigkeit in ein „Wir schauen uns mal ganz kurz einen Haufen Sprachen an“ zu bringen ist eine total beknackte Idee. Nebenläufigkeit ist so mit das härteste, fehleranfälligste, und leider nicht-deterministische Thema was man sich ans Bein binden kann. Das ist was für ein eigenes komplettes Buch in einer Sprache.

Meine Lösung für die async-Variante:

#!/usr/bin/env hy
(import hyrule *)
(require hyrule *)
(import asyncio [run sleep wait])
(import functools [partial])

(defn :async sort-me [n]
  (await (sleep (/ n 100)))
  (print n))

(defmain []
  (setv data [10 4 2 6 5 7 1 3])
  (run (-> (map sort-me data) (wait))))

Grundsätzlich finde ich es unschön, dass die Polymorphiebeispiele für die ganzen Sprachen leicht unterschiedlich sind, und man nicht weiss warum. Mal hat die Animal-Klasse Attribute und/oder Methoden, mal nicht. Und dann gibt es fälle wo die Klasse(n) gar keinen Sinn machen, und man das viel einfacher nur mit Funktionen hätte lösen können.

Ich habe nach Hy bei Io weitergelesen und da ist das mit den ”Klassen” ausserordentlich schlecht geschrieben. Im Grunde verpacken die ”Klassen” einfach nur eine Zeichenkette. Die Objekte werden da quasi als Wörterbücher mit genau einem festen Schlüssel/Wert-Paar verwendet.

Das wäre idiomatischer so etwas in dieser Richtung:

#!/usr/bin/env io

Person := Object clone do(
    name ::= nil
    age ::= nil
    
    info := method(
        self name .. " is " .. self age .. "\n" .. "They work in " .. self company
    )

    with := method(name, age, self clone setName(name) setAge(age))
)

XPerson := Person clone do(company := "X")
YPerson := Person clone do(company := "Y")

main := method(
    john := XPerson with("John", 23)
    alla := YPerson with("Alla", 22)
    john info println
    alla info println
)

isLaunchScript ifTrue(main)

Bei dem Sortieren ist auch bei Io wieder so ein doofes wait für eine feste Zahl an Sekunden am Ende wo man eigentlich darauf warten sollte, dass alles fertig berechnet/ausgegeben ist, und insgesamt fehlt mir so ein bisschen das idiomatische Methoden verketten bis der Arzt kommt von Io:

#!/usr/bin/env io

Sorter := Object clone do(sort := method(n, wait(n / 100); n println))

sort_me := method(n, Sorter clone @@sort(n))

main := method(
    list(10, 4, 2, 6, 5, 7, 1, 3) foreach(n, sort_me(n))
    while(Scheduler yieldingCoros size > 0, yield)
)

isLaunchScript ifTrue(main)

Und auch hier nervt mich wieder, dass Sleep-Sort, was so ziemlich in keiner Sprache wirklich sauber und sicher programmiert werden kann. Man muss immer darauf hoffen, dass es klappt, das Ausgaben nicht blockieren und ein anderer Teilnehmer sich nicht doch noch vordrängeln kann. Alleine wenn das über SSH ausgeführt wird, könnte eine Ausgabe mal eine Sekunde oder so blockieren, und schon kommt da Unsortiertes heraus.

sls Frust bei C++ kann ich verstehen, aber bei C? Das ist doch super simpel. Quasi so etwas wie ein plattformunabhängiger Makro-Assembler, weil man sich zu jeder Anweisung leicht den Assembler-Code vorstellen kann, den der Compiler dafür erstellt (ohne Optimierungen).

Der Algorithmus zeigt aber auch nicht wirklich etwas über Nebenläufigkeit und er ist wie schon gesagt, in vielen Sprachen gar nicht sauber, fehlerfrei implementierbar. Also im schlechtesten Fall 21 kaputte Beispiele für Nebenläufigkeit, juhuu. Dann die nicht wirklich vergleichbaren ”objektorientierten” Beispiele, weil da anscheinend bei jeder Sprache Ad Hoc ein ähnliches Beispiel auf's neue ausgedacht wurde, statt das man *ein* Beispiel hat, und dann die Unterschiede in den Sprachen daran zeigen/sehen kann. Und bei der Fakultät ein ungeeignetes Beispiel für Rekursion, weil das niemand rekursiv implementieren würde, oder wenn dann Endrekursiv, wenn die Sprache eine entsprechende Optimierung garantiert.

Bei den drei Sprachen die ich mir jetzt angeschaut habe, wird auch nicht wirklich auf die Besonderheiten der Sprache eingegangen, also die Punkte die diese Sprache von den anderen wirklich absetzt. Also das was an verschiedenen Sprachen eigentlich interessant ist, was sie besonders macht. Die wunderschöne Komplexität bei C++, Makros in Hy (oder Lisp/Scheme), was in Io Syntax ist und was als Methode implementiert ist, also wie verdammt klein der Sprachkern ist.

Ich würde gerne noch mal unterstreichen wie schlecht dieses Zoo-Beispiel ist. Man hat da nicht wirklich Polymorphie, weil sich Katzen und Hunde gar nicht anders verhalten. Die Methode kann auch einfach in die Basisklasse wandern, wie man an diesem Io-Beispiel sieht:

#!/usr/bin/env io

Animal := Object clone do(
    name ::= nil
    info := method(self name .. " is a " .. self type asLowercase)
    named := method(name, self clone setName(name))
)
Dog := Animal clone
Cat := Animal clone

main := method(
    list(
        Dog named("Charlie"), Dog named("Milo"), Cat named("Gracie"),
        Cat named("Molly"), Animal named("Sunny")
    ) foreach(animal, animal info println)
)

isLaunchScript ifTrue(main)

Aber selbst Animal ist ein „code smell“: Wenn man neben der Methode zum erstellen des Objekts nur eine einzige weitere Methode hat, dann ist das sehr oft einfach eine als Klasse verkleidete Funktion. Beispiel in Hy wie man das mit Funktionen lösen kann und dabei sogar noch ein bisschen flexibler ist, weil man zwar einerseits dedizierte Funktionen zum erstellen einer Katze oder eines Hundes haben kann, aber Katzen, Hunde, aber auch ganz andere Tiere mit create-animal erstellen kann.

#!/usr/bin/env hy
(import hyrule *)
(require hyrule *)
(import functools [partial])

(defn create-animal [name [kind "animal"]] {"kind" kind  "name" name})
(setv create-dog (partial create-animal :kind "dog")
      create-cat (partial create-animal :kind "cat"))

(defn get-info [animal] f"{(:name animal)} is a {(:kind animal)}.")

(defmain []
  (setv zoo [(create-dog "Charlie") (create-animal "Milow" "dog")
             (create-cat "Gracie") (create-animal "Molly" "cat")
             (create-animal "Sunny")])
  (for [animal zoo] (print (get-info animal))))

Und aus irgendwelchen Gründen werden bei vielen Sprachen auch nicht-rekursive Lösungen für die Fakultät gezeigt, aber nicht bei Hy:

(import math [prod])
(import functools [reduce])

(defn factorial-0 [n] (if (< n 2) 1 (* n (factorial-0 (dec n)))))
(defn factorial-1 [n] (prod (range 2 (inc n))))
(defn factorial-2 [n] (reduce * (range 2 (inc n)) 1))

Quote from __blackjack__

sls Frust bei C++ kann ich verstehen, aber bei C? Das ist doch super simpel. Quasi so etwas wie ein plattformunabhängiger Makro-Assembler, weil man sich zu jeder Anweisung leicht den Assembler-Code vorstellen kann, den der Compiler dafür erstellt (ohne Optimierungen).

Simple ain't easy, right?

Mir fehlt wohl ein praktischer Anwendungsfall. Ich fange immer wieder an Konzepte über C zu lernen aber bleibe dann nicht am Ball. Eventuell wäre ein Arduino oder anderes Entwicklerboard eine gute Idee. Keine Ahnung ob das so sinnvoll ist. Ich hatte mit Python damals als erste Programmiersprache angefangen und der Wechsel auf Java war erstmal überfordernd. Auch wenn Python einfach ist, passieren mir manchmal zu viele Dinge automagisch. Wenn man dann in C realisiert, dass man alles selber bauen muss (Arrays etc.) ist erstmal abschreckend, aber ja genau das was man will wenn man "lernen möchte"?

Eine Sache die ich Java und der JVM als Ökosystem mag ist die Community. Bei C++ wirkt die eher uneins über die Entwicklung der Sprache selbst. Und dass jeder ab einem gewissen Punkt seine eigene Standard-Lib implementiert.