Folge 90: Bunter Code

Wir sind in den 90ern angekommen! Das hindert uns nicht daran, zunächst mal sinnfrei in der 90er-Popkultur zu wildern. Es wird wirklich wild. Es werden die relevanten Fragen geklärt! Seid ihr im Team „Backstreet Boys“? Team „N’Sync“? Oder gar Team „Take That“?

Wie wir da die Kurve hinkriegen zum eigentlichen Thema? Gar nicht! Wie immer! 🙂
Heute geht es um den Blogpost „What color is your function“ von Bob Nystrom. Dieser ist schon etwas älter (von 2015). Wurde damals auch schon heiß diskutiert. Ist aber unserer Ansicht nach heute noch relevant. Also reden wir mal wieder über nen Blogpost.
Um es kurz zusammenzufassen: Dieser Blogpost bespricht im weitesten Sinne die Unterschiede zwischen synchronem und asynchronem Code. Wie verhält er sich, wie rufe ich den auf? Welche Auswirkungen hat asynchroner Code auf den synchronen Code?
Das Posting geht dann in seiner Saloppheit relativ tief ins Eingemachte: Call Stacks, Green Threads usw. Sehr lesenswert aus unserer Sicht.
Wir sind dann natürlich sehr schnell wieder im JavaScript-Land unterwegs. Spannen den Bogen aber natürlich Richtung JVM und auch Richtung Go.

Die Antwort auf alle Fragen ist natürlich wie immer Akka. Da sind wir uns natürlich alle einig. Naja, vielleicht… 🙂

Wie seht ihr das? Wie steht ihr zu roten und blauen Funktionen? Und asynchronen Funktionen? Seht ihr das genauso wie Bob Nystrom? Sollten alle Funktionen rot sein? Habt ihr Details zu Goroutinen?

Dank euch fürs Zuhören! Bleibt gesund!

Links

Bier

Der Bene war mal wieder schön einkaufen!

Kommentare

Eine Antwort zu „Folge 90: Bunter Code“

  1. Avatar von Björn
    Björn

    Es hat lang gedauert, aber bei der 90. Folge muss ich dann doch mal einen Kommentar loswerden…

    Für mich ist heute beim Craftbeer-Trinken und Konsumieren eures heiteren und normalerweise fundiertem Podcasts eine Welt zusammengebrochen 😉 Zu so einem grundlegenden Thema wie Threads so viel Verwirrung in ein paar Minuten, das war schon gekonnt 😛

    Dass ein Javascript-Entwickler das Wort Thread nur vom Hören kennt und eine automagische Parallelisierung von Aufgaben durch das Betriebssystem postuliert, sei mal darauf zurückzuführen, dass Web-Anwendungen ja keine richtigen Anwendungen sind und man daher mit einem Thread auskommt und den Rest einfach dadurch totschlägt, dass man auf performantere Hardware wartet oder den User einfach warten lässt 😉 (ich muss ich hier mal die polarisierende Rolle einnehmen, die fehlte in der Folge auch :P)

    Benedikt hat die Folge ja schon dadurch gerettet, dass er (fast) die wesentlichen Gründe für den Preis von echten Threads genannt hat. — Allerdings war der Talk dann doch eher in 2015 angesiedelt als in der Gegenwart.

    Ihr könnt euch aber rehabilitieren, wenn ihr mal einen erfahrenen Kotlin-Entwickler zu euch als Gast holt, der über Android-Entwicklung erzählt. Es ist dort tatsächlich so, dass es mit Kotlin Coroutines die „leichtgewichtigen Threads“ in einem sehr durchdachten Gesamt-System gibt, das im Zusammenspiel mit Kotlin Flow dem Entwickler ein solides reaktivtes Framework an die Hand gibt, damit er gute, performante Android Apps schreiben kann, die auch wirklich die Hardware ausnutzen — ja, Performance zählt auf solchen Geräten noch!

    Lasst euch nicht von mir ärgern, aber denkt mal drüber nach, so jemanden einzuladen!

    Macht weiter mit eurem tollen Podcast, ich bleibe euch trotzdem treu 🙂

Schreibe einen Kommentar zu Björn Antwort abbrechen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert