Transkript: PP04 - Python für Einsteiger

Ja, hallo liebe Hörerinnen und Hörer.

Willkommen beim Python Podcast in der vierten Episode.

Heute geht es darum, wie man am besten Python lernen kann oder anderen Menschen Python beibringt.

Was machen wir eigentlich?

Ja, wir sind diesmal tatsächlich nicht mehr in der Raumschiff-Kommandozentrale, sondern wieder bei Jochen im Wintergarten.

Ja, ich habe so ein bisschen was an Equipment geupgradet und mal gucken, wie das jetzt so wird.

Wir haben jetzt zwei Headsets richtige und auch so ein bisschen mehr Mischpult ist jetzt heute als sonst, weil wir uns dann zu diesem Thema zwei Leute noch mit dazu geholt haben.

Genau die

vielleicht da was.

Die haben mich in der Dodo aus dem Fahrrad mitgebracht.

Hallo, hallo, hallo.

Die dort die Einsteigerveranstaltung für Python halt jetzt schon seit einiger Zeit betreuen und dann genau.

Die sehr gute Einführungsfrage.

Nicht zu viel loben.

Ja, ja.

Und genau, ja, mal schauen, wieso wird es damit.

Ja, Fragen, Anmerkungen, Kommentare und alles, was ihr so loswerden müsst, bitte immer gerne in unsere E-Mail schreiben.

Hallo.pythson-podcast.de Dabei auch direkt vielen Dank an Kommentare, schöne bei der letzten Folge.

Einmal groß nach Rostock und an den Matthias und in die Schweiz, an den Dirk.

Genau.

Und das war sehr positiv und das ist natürlich mal sehr, sehr schön, wenn man da auch irgendwie mitbekommt, dass das so ein bisschen wahrgenommen wird.

Die Punkte, die da angesprochen wurden, waren einmal, dass es halt nett wäre, wenn wir jetzt irgendwie Kommentare doch auch dabei hätten.

Und dazu haben wir uns natürlich auch schon irgendwie Gedanken gemacht und haben erstmal gesagt, wir lassen die bewusst weg, weil, naja, das ist halt irgendwie alle Zeit, die wir da rein investieren müssen, einmal das Feature zu bauen, aber dann auch irgendwie das Ding Kram zu maintainen, können wir halt nicht irgendwie zum Aufnehmen von Vodcasts verwenden.

Aber ja, also.

Genau, falls unser Axt mal stumpf werden sollte, dann denken wir nochmal über die Kommentare nach.

Ja, also ich meine, ich glaube, es ist auch nicht so schwierig, das zu implementieren und wenn man das auf User beschränkt, die sich irgendwie eingeloggt haben, aber das ist halt die Frage, wie sinnvoll das da noch ist,

wenn man das

macht, dann ist das auch nicht allzu schlimm.

Aber ja, wir müssen mal gucken.

Es gibt ja eine ganze Menge Dinge, die wir da eventuell noch einbauen wollen.

Ja, das kannst du vielleicht gleich nochmal bei der Modulvorstellung von deinem neuesten Dango Cast-Fortschritt erwähnen.

Was die Leute sich auch gewünscht hatten, hatte unsere Hörer war Struktur.

Ja, stimmt, das ist natürlich schon so ein gewisser Punkt.

Ja, wir versuchen das aber trotzdem heute mal umzusetzen.

Wir haben uns heute einfach auf ein Thema beschränkt, da ist die Struktur vielleicht nicht so wichtig.

Wir fangen vielleicht erstmal nochmal damit an, was in letzter Zeit denn so los war und dann erzählen wir halt darüber, was man mit Python alles lernen kann.

Und ja, vielleicht noch ein paar Module, die wir so

können, aber vielleicht machen wir einfach erstmal eine Vorstellungsrunde.

Ich meine, wir werden, genau, gut, wir beide sind jetzt schon irgendwie bekannt, aber wer ist denn, wer seid ihr denn?

Ja, ich würde sagen, Alter vor Schönheit.

Ich bin der Dodo oder der zweite Dominik.

Ich mache zusammen mit dem Nick das Python Fu Light im Chaosdorf.

Das ist das Python-Vu für Anfänger in Python oder Anfänger in Programmierung im Allgemeinen.

Das ist jeweils der erste und zweite Donnerstag im Monat.

Und ja, da versuchen wir Leuten Python als Programmiersprache beizubringen.

Und das machen wir jetzt seit zwei Jahren.

2015, oder?

Ja, ich glaube.

Mittlerweile drei Jahre.

Irgendwann im Sommer, ja.

Ja.

Hier kann man übrigens immer gerne vorbeikommen.

Natürlich.

Ich bin ja Niklas, hallo.

Wir haben es damals angefangen, ich glaube, irgendwie ein halbes Jahr, nachdem es den Game Dev gab.

Es gibt da gewisse personelle Überschreitschneidungen mit Leuten, die dann halt nicht mehr die Zeit hatten, auch noch den Python Foo viermal im Monat zu machen.

Und dann sind wir halt eingesprungen in den ersten beiden Donnerstagen.

Ja, vor allen Dingen hatten wir festgestellt, dass sich gerade Anfänger häufig erschlagen fühlen, wenn sie zum Python Fu kommen und über viel komplexere Themen besprochen wird als sie, die ihnen jetzt erstmal nichts sagen, weil sie gerade mit Python anfangen möchten.

Und da dachten wir, dass eine Veranstaltung, die sich eben dediziert an die Anfänger wendet, wo man dann auch die blödsten Fragen stellen kann, doch eine ganz gute Sache wäre.

Da dachten wir, wenn jemand die Anfänger erschlägt, dann wir.

Genau.

Und wenn jemand blöde Fragen beantwortet, dann wäre ja immer noch wie das.

Wir stellen die auch meistens.

Ja.

Ja, das klingt doch auf jeden Fall gut.

Und ja, vielleicht können wir euch dann auch direkt mal auf dem Kalt, beziehungsweise auf dem falschen Fuß erwischen, wenn wir euch fragen, was habt ihr denn in letzter Zeit so an Python-Neuigkeiten mitbekommen?

Weil das ist ja vielleicht auch ganz interessant, was da so, wenn man jetzt nicht irgendwie da bewusst für entscheidet, irgendwie diese News da zu konsumieren, was dann da irgendwie hängen bleibt.

Also ich lese ab und zu die Release-Notes zu neuen Python-Versionen, aber es gab ja jetzt schon ein halbes Jahr keine mehr.

Eigentlich nicht so wirklich, nein.

Ich glaube, das letzte, was ich gelesen hatte, also hin und wieder bekomme ich halt von den neuen Releases was mit.

Das letzte, was ich mir angeschaut hatte, waren die Data Classes, die jetzt in den neueren Python-Versionen vorkommen sollen.

Die hatte ich mir einmal angeguckt.

Naja, die Python-News lese ich meistens als RSS-Feed.

Da habe ich mir von Planet Python den RSS-Feed gezogen und kriege da ganz unterschiedliche Nachrichten jeweils.

Das ist auch relativ interessant.

Ich setze mir dann meistens einfach nur eine Flagge im RSS-Reader-Reader, weil meistens komme ich dann nicht dazu, die Nachrichten komplett zu lesen, sondern habe nur die Kurzbeschreibung.

Aber ich finde, das ist ein sehr gutes Mittel, um News über Python zu bekommen.

Ich habe meinen RSS-Reader seit irgendwie drei Jahren nicht mehr aufgemacht.

Einige zehntausend Nachrichten.

Die letzten neue Feature von Python, das ich verwendet habe, waren Name Tupes, glaube ich.

Das fand ich ganz cool, so als einfacher Klassenersatz.

Es gibt noch einen coolen Newsletter für Python, ne?

Oh, Newsletter.

Ja, ja.

Stimmen wir auch die Shownotes dann vielleicht mal rein.

Ja, das ist ja nicht so.

Es gibt ein paar, ich habe irgendwie einen Awesome Python, einen Python-Weekly, dann einen Punkt.

Ich habe auf GitHub die Trending-Repos abonniert.

Das gibt es für mehrere Sprachen und unter anderem auch für Python.

Oh, das ist so.

Das ist halt teilweise Sachen, die halt irgendwie nur zufällig in Python sind und nicht wirklich dafür relevant sind.

Aber manchmal ist es auch was Spannendes dabei.

Das klingt auf jeden Fall interessant, ja.

Da können wir vielleicht einfach einen Punkt machen, wo wir so ein bisschen sammeln, wie man sich eigentlich da aktuell halten kann.

Ja, also ich bin auch ein großer Fan von RSS und ich habe eigentlich auch irgendwie, ich verwende schon ganz lange einen Feed-Reader.

Bin dann da irgendwie gab es ganz am Anfang irgendwie Aggregator verwendet oder KDE.

Und dann gab es aber den Google Reader und der war so gut.

Den fand ich total toll.

Und den habe ich ganz lange verwendet.

Ich habe ganz lange dieses Sharing-Feature verwendet, was auch viele andere irgendwie gern benutzt haben.

Und da gab's, da gab es ganz tolle Sachen.

Und das war irgendwie so ein, das war das einzige Mal, dass so Social Network für mich so ein bisschen funktioniert hat.

Und dann hat Google den Reader eingestellt oder es war ganz furchtbar.

Und jetzt habe ich zwar immer noch einen Feed-Reader, aber es ist irgendwie alles nicht mehr so das Gleiche.

Und genau, ich habe da auch Plan in Python und da noch so ein paar Blogs von Leuten, die halt, die halt da an Python und halt an Jungroom entwickeln, halt auch abonniert.

Ja, genau, ja, das mit dem Data-Class, das ist Python 3.7 oder es gibt ja jetzt vorletzte Woche, glaube ich.

3.8 nochmal ein paar Ankündigen, genau.

Genau, da gab es eine neue Alpha-Version und zwar gibt es da auch eine Syntaxänderung.

Ich weiß nicht, ob ihr von der schon gehört habt.

War das das mit dem Doppelpunkt gleich, dass man in das war doch, dass man in, wie war das?

In Schleif, in der Deklaration von einer Weil-Schleife kann ich mir die Variable setzen, oder?

Das war eine Zuweisung, die dann auch wieder direkt den Wert hat.

Genau, also man hat eine Zuweisung und hat gleichzeitig hat die ihn irgendwie gekriegt, weder true oder false.

Es gab da auch irgendwie einen witzigen Namen für den Operator, ne?

Wallbrust-Apparat, weil das so ein bisschen

aussieht wieder.

Das ist ein bisschen wie dieser Turbo-Fisch, du hast, ne?

Ja, das hatte ich auf Twitter, glaube ich, mitbekommen.

Das hatte mir irgendwer retweetet.

Das fand ich auch sehr interessant.

Aber.

Ja, und genau, man kann sich damit halt, also man halt macht halt oft sowas wie, man holt irgendwas einen Wert aus einem Dikt und dann muss man erstmal überprüfen, ob das nicht nun ist, weil man weiß halt nicht, ob es.

Und die Zeile kann man sich jetzt immer sparen und man schreibt dann halt direkt if irgendwie dann irgendwas, Valros Operator vedt.getKey, dann macht man halt weiter, wenn es drin war und ansonsten.

Ansonsten wäre für sowas ja auch so ein Safe Navigation Operator nett.

Es gibt ja Sprachen, da kannst du irgendwie Fragezeichen Punkt machen und die machen den Zugriff nur, wenn das Objekt selber nicht null ist.

Ein Safe Navigator, das musst du bitte

kurz erläutern.

Also es ist ja auch paffi so, dass du irgendwie ein Objekt hast und es hat ein Attribut.

Da machst du irgendwie Objekt, Punkt, Attribut, Punkt irgendwas.

Und eigentlich musst du ja bei jedem dieser Schritte prüfen, ob das Attribut selber nicht Nun ist.

Du kannst ja nicht Punkt machen.

Es gibt halt Sprachen, die haben so einen Syntax-Fragezeichen-Punkt.

Die macht halt den Zugriff nur, wenn das Objekt selber nicht NAN ist.

Und ansonsten ist der Wert halt auch direkt wieder NAN.

Das fände ich cool, kenne ich bei Python nicht.

Ja, und da hatten wir tatsächlich einen.

Ich weiß nicht, kennt ihr das?

Es gibt einen Telegram-Channel zur Python-User-Group Düsseldorf, PyDDF.

Nee, kenn ich nicht.

Ah, ja, offen.

Die User-Group, die kenne ich, da war ich ein paar Mal, aber den Telegram-Channel sag ich mir nicht.

Genau, es gab auch lange eine, oder es gibt immer noch eine Mailingliste, aber der Telegram-Channel ist tatsächlich was, was jetzt auch stärker genutzt wird.

Und da gab es eine Diskussion genau darüber und Chesi, der zu dem wir als Expertengast vor unserem Django-Folge da hatten, hat da auch irgendwie quasi, es gibt einen Python-Enhancement-Proposal, wo genau so eine Syntax mit einem Fragezeichen vorgeschlagen wird für hat das dann halt auch irgendwie da mal vorgestaltet und meinte so, das wäre doch eine tolle Idee.

Und dann hat sich das aber relativ, das war sehr

kontrovers, das

war eine sehr polarisierende.

Also ich habe es auch noch nie genutzt, ich weiß nur, dass das existiert in anderen Sprachen.

Ja.

Ich bin mal gespannt.

Kann ja sein, dass es auch in Python irgendwann kommt.

Also es gibt noch mehr Neuigkeiten dann irgendwo von dem Steering Council.

Da wollte vielleicht noch was zu sagen, nur so.

Genau, ich hab da jetzt, ich habe das auch nicht so im Detail verfolgt, aber es ist halt so, dass Guido ja sozusagen so einen unbegrenzten Urlaub genommen hat von seiner BFDL-Rolle.

Guido das Hippo, also wo wir eben bei den Tieren waren, war er aus Hippo.

Weil der, glaube ich, gar nicht so gut bezahlt ist, ehrlich gesagt, aber genau, der ja, und jetzt gibt es halt einen Steering Council gewählt worden, der halt dann, wenn quasi eine Entscheidung benötigt wird und das sonst niemand tun will und so, und man dann halt irgendwie ein letztes, äh, jemand irgendwie das letzte Wort haben muss, dann gibt es halt diesen Rat, der das dann hat, halt hat.

Und da sind halt irgendwie fünf Mitglieder reingewählt worden, unter anderem auch Guido.

Und genau, das werden wir auch verlinken, kann man sich ja mal angucken.

Es ist alles nette Leute insofern.

Ja, sieht gut aus.

Und es gibt noch eine nächste Neuerung, zwar gibt es jetzt lokale Packages in Python.

Oder sollte man sagen?

Ne, das gibt es auch erst mit unter 8.

Genau.

Genau, ja.

Ja, ja, ja.

Stimmt, das war auch eine Alpha-Release drin.

Python Local, ähm, ja, Pip Local gibt es so ein Verzeichnis dann.

Ui, jetzt muss ich mich versuchen daran zu erinnern, was das eigentlich genau.

Das ist quasi dann so ähnlich wie bei JavaScript und dass man halt die Pakete, die man installiert, halt in dem Verzeichnis, in einem speziellen Verzeichnis direkt hat.

Und dann irgendwie drumrum kommt, sich mit diesem ganzen Virtual Env-Kram rumschlagen zu müssen.

Ah, also quasi man konnte doch bisher auch schon bei Pip Install irgendwie TenTarget angeben.

Und dass das dann, ah, okay, ja.

Und das ist dann, glaube ich, einfach ein, das dann heißt dann einfach PipLocal und dann installiert es das halt in das Verzeichnis rein und dann.

Hast du alles in einem Ordner?

Genau.

Ja, auch gar nicht so schlecht.

Also ich weiß nicht, ob es jetzt Virtual Ends komplett ersetzen wird, dann, aber es ist auf jeden Fall.

Also ich meine, gut, wir haben ja jetzt erst drei oder vier unterschiedliche Arten, wie wir das machen können, wird das bestimmt das Problem lösen.

Das beste

ist natürlich Pip-End.

Ja, das stimmt, das ist schon gut.

Ja, aber genau, zu sowas.

Isolation, Virtual Ends, Docker, diesen ganzen Kram, wie kriege ich eigentlich unterschiedliche Projekte auf einer Maschine irgendwie so installiert, dass sie sich nicht gegenseitig kaputt machen.

Dazu müssen wir auch mal.

Wir haben eine Extra-Folge auf jeden Fall.

Ja, dann fangen wir doch jetzt am besten mit unserem Thema an, oder?

Also wie lernt man denn Python so am besten?

Puh.

Ja, ich glaube, das hängt viel von einem selber ab.

Also es gibt verschiedene Arten, wie man Python lernen kann.

Und ich würde sagen, da muss man so für sich die beste Art und Weise rausfinden.

Die Frage ist ja auch, kann man schon programmieren?

Kennt man vielleicht andere Programmiersprachen, die sich ähnlich verhalten, was Objektorientierung und sowas angeht?

Oder muss man das auch noch erstmal lernen?

Ja, und wenn man schon eine andere Programmiersprache hat, gibt es natürlich, sind gewisse Einstiegshürden einfach nicht mehr da.

Also wenn ich schon mal im Texteditor ein Programm geschrieben habe, dann muss mir nicht mehr erklärt werden, wie ich mit einem Texteditor arbeite.

Wenn ich schon mal eine Idee bedient habe, weiß ich, was eine Idee ist.

Oder Schleifen.

Genau.

Das geht natürlich weiter mit den Kommandostrukturen.

Wenn ich eine If-Bedingung kenne ich dann, wenn ich schon mal programmiert habe, eine Schleife etc.

Wenn ich schon mal mit einer stark objektorientierten Programmiersprache gearbeitet habe, muss man mir Objektorientierung nicht mehr erklären.

Also da kommt es, gibt es dann Einstiegshürden, je nachdem, ob ich mich schon mal mit einer Programmiersprache beschäftigt habe, eventuell sogar mit einer, die Python sehr ähnlich ist.

Ansonsten sind halt so Sachen wie irgendwie Namespaces oder dynamische Typisierung vielleicht eventuell sogar einfacher zu lernen, wenn man es aus einer anderen Sprache noch nicht kennt.

Ja, das heißt, wenn du nicht gewohnt bist, dass du deine Variable einen festen Typen hast, ja, dann könnte es sogar einfacher sein.

An der Stelle bietet Python natürlich einen einfachen Einstieg, weil es eben eine dynamische strenge Typisierung bietet.

Strengdynamisch.

Ja, ich hab so, die hat auch gemacht so auf Hackathons oder so, wo ich dann irgendwie Leute hatte, die dann halt sehr aus sehr unterschiedlichen Bereichen kamen und aus sehr unterschiedlichen Wissensstand hatten und dann hat man versucht, irgendwie so ein Projekt zu machen mit denen.

Und dann, ja, genau, versucht man halt einfach nur irgendwie das Projekt zu bootstrappen.

Das heißt, irgendwie, die müssen irgendwie Python installieren, dann irgendwie irgendwas aus Git ziehen, dann ein Virtual Env erzeugen, dann irgendwie die Abhängigkeiten installieren.

Und dann sind zwei Tage rum.

Und genau, und das ist teilweise, weil was mir dann immer passiert, oder die schlimmsten Fälle sind immer nur so, ja, okay, Python installieren.

Ja, aber das ist mein Firmenrechner, da ist ein Windows drauf und ich kann da auch eigentlich nichts installieren.

So, dann ist schon mal so,

okay, dann ist man halt

vielleicht nach einer Stunde irgendwie so, dass man eine Python-Shell hat.

Aber wie geht ihr damit um?

Oder macht ihr irgendwie Ansagen, was schon vorausgesetzt wird, wenn man überhaupt da hinkommt?

Also um den ganzen Kram drücken wir uns ein bisschen.

Einerseits, wir verwenden zumindest am Anfang nichts, was irgendwie extra Module braucht.

Also man braucht einfach nur einen Python-Interpreter.

Und viele Systeme, irgendwie, weiß ich nicht, OS X oder die meisten Linux-Distros, haben ja einen schon dabei.

Und wenn jemand einen Windows-Rechner mitbringt, haben wir so die Hoffnung, dass die Person weiß, wie man da auf Programme installiert.

Weiß ich nicht.

Bei den

meisten Leuten,

die ins CrossFoft kommen, hat das dann vielleicht auch funktioniert.

Ansonsten kann man sowas ja im Notfall auch irgendwie online machen.

Es gibt ja irgendwie Zeiten Anywhere oder sowas.

Das geht ja irgendwie.

Außerdem haben wir, glaube ich, im Wiki die Ansage stehen, dass man, wenn man zum Python vorkommt, einen Rechner mitbringt und auf diesem Rechner.

Genau, Ausrufezeichen.

Okay, ja.

Das kann man vielleicht ein

Raspbi ausleihen oder sowas.

Ja, oder auch auf vielen Android-Smartphones.

Wenn du ein Handy neuer als Android 5 hast, kannst du da Python drauf installieren, problemlos.

Gut, das Tippen ist ein bisschen ekelhaft auf dem Smartphone.

Sehr gut, Bluetooth-Tastatur.

Oder sowas, ja.

Ja, meistens haben wir ja sogar Linux-User, da Windows-User sind natürlich, wenn es um die Installation von Paketen geht, immer ein bisschen fummelig, aber im Allgemeinen kriegen wir das auch hin.

Also gerade so Sachen wie irgendwie installiere das mal von Pip oder so, das machen wir nicht am ersten Abend.

Genau.

Das ist einerseits natürlich da, um die Einstiegshürden zu nehmen, denn so können wir das auf Windows, MacOS oder Linux machen, weil wir dann eben nur die Standardbibliothek nehmen und einfach nur einen Texteditor und einen Python-Interpreter brauchen.

Wir hatten witzigerweise noch niemanden, der dann irgendwie mit ReactWare ist oder BSD oder sowas aufgetaucht ist.

Ich glaube, das brauchen wir auch nicht.

Ja, okay, aber das ist ja schon mal schon mal interessant.

I verwendet dann einfach die ganz normale Python-REPL oder was gar nicht mehr das.

Also wir zeigen die Beispiele meistens entweder im Texteditor oder irgendwie in iPython, B-Python.

Aber das braucht man dann ja nicht, um das nachzuprogrammieren.

Das sieht dann halt nicht so schön aus.

Aber ja, und ansonsten, wir haben halt auch nicht so viele Anforderungen.

Also Beispiele laufen auf allen Versionen, die neuer sind als 3.4 oder so.

Und das hat ja sogar Debian Rolls Stable oder sowas.

Das ist ja kein Problem.

Das ist ja auch ein Vorteil der Python-Standard Library, dass die eben so umfangreich ist, dass man die meisten Sachen gar nicht nachinstallieren muss, sondern so viel schon dabei ist, dass man für ein grundlegendes Verständnis der Sprache brauchst du eben nur die Standard Library.

Wenn das dann ins komplexere Sachen geht, also wo du wirklich konkret was machen willst, da installierst du dir dann eine Library, aber.

Request ist, glaube ich, so die erste, die wir dann immer zeigen.

Genau.

Stimmt.

Und UPy.

Stimmt.

Ja, aber das ist eine Datei mit 56 Zeilen, dass ich glaube.

Die muss man nicht installieren, die kann man im Notfall herunterladen.

Genau.

Die könnte man wahrscheinlich so gar abtippen.

Was war das nochmal genau?

Ich habe das, glaube ich, gerade nicht so richtig verstanden.

HewPy kenne ich gar nicht.

Das ist ganz schön, um einfache Statusmeldung auszugeben.

Das macht dann halt irgendwie, es gibt Upy App.info und dann bekommst du irgendwie so einen blauen Kasten links und eine Welle und dann rechts den Text.

Farben im Terminal.

Es funktioniert auf allen Systemen.

Also Windows nur neuer als 10, aber ansonsten.

Und es ist halt eine wirklich kleine Datei.

Wenn du dir zeigen, glaube ich, die machen ekelhafte Sachen mit Dictionaries und Lambdas und sowas, aber das muss man ja nicht wissen.

Also das Gitter-Prepo da ist sehr erhellend, weil dann auch.

Sweetme ist ja gut.

Ja, das Readme ist sehr gut, weil da der Entwickler da vergleicht, wie schwierig es ist, mit anderen Bibliotheken Farbe ins Terminal zu bringen und wie einfach das mit UPy ist.

Ja, diese Tabelle, wo nur UPy die höchste Punktzahl erreicht.

Ja, ein bisschen Eigenwerbung soll ihm ja auch gegönnt sein.

Ich verwechsel das nur leider immer mit Philips-Flamm.

Genau.

Ja, UPy und Python Hui sind zwei verschiedene Dinge.

Wichtig zu wissen.

Willen zu dem irgendwo die falsche Wann fangen.

Wie habt ihr dabei denn Python gelernt?

Ich weiß es ehrlich gesagt nicht mehr.

Ich glaube, ich habe früher mit einem Freund zusammen PHP angefangen, irgendwann an Grundschule.

Und dann fanden wir irgendwann PHP nicht mehr cool.

Und dann ist er zu Pearl gewechselt und ich fand Pearl auch nicht cool.

Dann habe ich mir angeguckt, was gibt es noch so an Sprachen und dann bin ich mit Python angefangen.

Hat er festgestellt, Python fängt auch mit P an.

Ja, genau.

PHP, Pearl und Python ist eh fast das gleiche an.

Ja, bei mir war das deutlich später als die Grundschule.

Ich weiß noch, ich hatte in der 8.

Klasse oder 9.

Klasse Wahlpflichtfach Informatik.

Ah ja.

Und in der Schule hatten wir dann in der 8.

Klasse Word und Excel und in der 9.

Klasse haben wir dann auch richtig programmiert mit Turbo Pascal.

Wir hatten damals schon PHP in der Schule.

Eigentlich hat es mir Spaß gemacht, mit Turbo Pascal zu programmieren, so viel Spaß man eben damit haben kann.

Oh doch, das war toll.

Ich weiß jetzt nicht, welche Version ihr da verwendet hat, aber.

Ich hatte da mal.

Naja, alles gut.

Dein Handy.

Ach ja, das ist in Ordnung und das macht ja nichts.

Der Tee war lecker.

Ja.

Danke haben.

Also genau, damals war das irgendwie Turbo Pascal 5.5 und das lief alles sozusagen auch irgendwie in einer Shell oder sozusagen auf der MS-DOS-Kommandozeile.

Und das war als IDE eigentlich tatsächlich ziemlich klasse, wenn man irgendwie auf F9 gedrückt hat, dann hat das irgendwie sofort kompiliert und es ausgeführt und man konnte so einen Debugger durchsteppen und so.

Das war, ja, aber keine Ahnung, wie das bei euch war das dann wahrscheinlich schon Windows oder so.

Ja, ich glaube, wir hatten da eine Free Pascal, das war so ein bisschen wie Python-Idol, nur ich fand es halt sauanstrengend mit Turbo Pascal zu kombinieren.

Und irgendwann war die 9.

Klasse dann fertig und ich glaube, so zu den Sommerferien fing dann im Chaosdorf das Python Fu an, weil das bekam halt das Karosdorf bekam halt neue Räume.

Ach, du hast die alten Räume noch gesehen?

Ja, ja.

Oh.

Und da fing erst Python Fu dann auch komplett im Renovierungsmodus mit Umfug auf Python 3.

Genau.

Man könnte sagen, es lag am Umzug auf Python 3, aber nein, da wurde gerade das Carrosdorf umgebaut.

Und ja, da fing dann das Python Fu an.

Und da ich halt eine etwas modernere Programmiersprache lernen wollte, ja, habe ich dann da angefangen.

Dann habe ich mich zwei Jahre relativ intensiv mit Python beschäftigt.

Bin auch so ungefähr bis zur Objektorientierung bekommen.

Die war mir dann aber zu kompliziert und bin bei funktionaler Programmierung geblieben.

Ja, und dann.

Ja, Objektorientierung habe ich auch nie wirklich verstanden, bis ich zum Beispiel vorgekommen bin.

Ja.

Später habe ich dann wieder eingesetzt und ja, seitdem beschäftige ich mich damit hobbymäßig.

Und Just von.

Naja, weil Geld bekommen wir dafür nicht.

Naja.

Ja, aber ich meine, ihr habt ja dann wahrscheinlich auch schon eine Menge Leute sozusagen kommen und gehen sehen.

Gibt es denn irgendwie welche, die dann irgendwann mal dazugestoßen sind und dann halt länger dabei geblieben sind?

Ihr verfolgt ja wahrscheinlich auch, was dann so ein bisschen mit den Leuten passiert.

Ist das eher eine Sache, die einen dann motiviert oder ist es deprimierend, dass alle Leute dann doch wieder irgendwann aufhören und verschwinden?

Jetzt war einer davon sitzt ja hier.

Du wirst jetzt überlegen, wer.

Wir sind meistens da.

Ja, ich glaube, ein paar Leute sind tatsächlich zum Python-Fu hinzugekommen.

Aber meistens hatten die schon ein bisschen Background Python-Technik.

Es gibt halt Leute, die kommen einmal, die kommen zweimal.

Und es gibt Leute, die kommen immer wieder.

Genau.

Das ist, glaube ich, auch so eine Schwierigkeit von dem Termin, dass wir eben die ersten beiden Donnerstage im Monat haben und dann ist nach dem zweiten Donnerstag wieder ein Monat dazwischen.

Haben sie wieder vergessen, da kommen sie nicht mehr.

Haben sie wieder vergessen.

Da wäre, glaube ich, tatsächlich wöchentlich oder wie zweiwöchentlich oder sowas.

Alle zwei Wochen jedenfalls ein regelmäßigeres Treffen, glaube ich, sinnvoller.

Wie oft habt ihr denn schon die erste Lektion Leuten gezeigt?

Die erste können wir am besten, weil wir es am häufigsten getan haben.

Also das ist natürlich bei uns auch ein völlig progresser.

Wir haben uns da mal eine sehr schöne E-Mail geschrieben, warum wir alles zu schnell machen.

Auf die wir auch nicht geantwortet haben, weil die sind super.

Ich fand es übrigens

nicht so schnell.

Ja, also die erste Lektion, ich glaube, 20 Mal haben wir die bestimmt schon gemacht.

Mehr.

Ich habe jetzt grob im Kopf überschlagen, aber tatsächlich ist das bei uns natürlich auch ein steter Vorgang, dass wir uns immer wieder verbessern.

Ich finde das ganz schön.

Wir haben die Beispiele und auch die Hinweise ja auch so ins Git-Repo und da kann man sehen, was wir beiden geändert haben.

Im Git-Repo könnt ihr einmal kurz die Adresse nochmal sprechen.

Wir diktieren die.

Könnt ihr die nicht einfach nicht mehr sehen?

Ja, ja, doch, doch, genau, die packen die die Show Notes um.

Ihr findet das Repo in den Shownotes.

Ich glaube, das ist das auch schon in der ersten Folge, oder?

Aber das ist ja schon, ich meine, wenn man das ein paar Mal gemacht wird, gemacht hat, das wird ja dann immer polierter.

Habt ihr mal darüber nachgedacht, dass irgendwie, keine Ahnung, irgendwie davon einen Screencast zu machen oder das irgendwie mal mitzusteigen und zu veröffentlichen oder so, weil das ja nicht so viel?

Wir sind ja nicht Geld getrieben.

Nee, darum geht es ja gar nicht, aber einfach, weil so viele Leute, die das so oft gemacht haben, gibt es ja wahrscheinlich gar nicht, die in so einer Anführungsveranstaltung irgendwie tatsächlich.

Wir haben uns halt überlegt, dass wir das Git-Prepo möglichst ausformulieren, dass halt auch Leute, die nicht zu der Veranstaltung kommen, sich das angucken können.

Screencast haben wir bisher nicht gemacht.

Nee.

Da müssten wir uns ja auch hinsetzen und das schneiden und so.

Ja, das stimmt.

Der verbringen halt meistens wirklich nur Zeit, wenn wir da sind.

Der Vorteil ist halt, wenn wir da mal Abend haben, wo niemand kommt, können wir in den Beispielen arbeiten.

Ja.

Das ja auch schon mal vorkommt.

Ja, prinzipiell ist das natürlich auch eine schwierige Sache, weil, wie gesagt, es gibt verschiedene Arten davon, wie man das am besten lernt, so für einen selber.

Und klar gibt es die Leute, die einfach nur Code lesen und den abarbeiten können, aber es gibt natürlich auch die Leute, die möchten, dass man denen das erklärt und mit denen macht.

Und deshalb fände ich es schwierig, quasi den Code so zu halten, dass der für alle passt.

Deshalb sind wir da ja auch relativ anpassungsfähig, je nachdem, wer zu uns kommt.

Wenn jetzt auffällt, dass Leute tatsächlich relativ selten Fragen stellen.

Da sollten wir vielleicht auch noch häufiger gucken, dass das passiert.

Ja, dass wir das interaktiver gestalten, meinst du?

Ja, was ist das?

Warte ich aber letztens ein paar Ideen.

Und diese E-Mail.

Eine interessante

Strategie, die ich schon ein paar Mal gesehen habe, die ganz gut funktioniert, ist, ist, wenn die Leute halt sich nicht trauen oder so Fragen zu stellen, dass man dann einfach als derjenige, der irgendwie eine Schulung macht oder irgendwie einen Vortrag hält oder so, dann einfach vor allen Dingen, wenn es nicht so viele Leute sind, geht das gut, dann die Leute fragt.

Oh wunderbar.

Das habe ich früher in der Schule schon gehört.

Ich meine, das Gute ist ja, dass wir meistens zu zweit uns dann auch selber in dem Ball so ein bisschen zuspielen können.

Unsere Überleitungen sind immer grandios.

Oh ja.

Wir sind berühmt.

Gerade zum Berühmt.

Ich hoffe so positiv.

Ja, ich glaube, wir haben da durchaus noch Verbesserungspotenzial, gerade was den Beispielcode angeht.

Poolrequests sind keine gesehen.

Gerne, genau.

Ja.

Ich glaube aber, dass wir das schon relativ gut hinkriegen.

Bis zu welchem Level geht denn der Python Food Light?

So lange, bis Leute bleiben.

Wir haben das ja in Level aufgeteilt, die er gerade schon erwähnt hat, damit man das quasi, ja, damit jemand der zu uns kommt, den können wir dann sagen, guck mal, wir haben hier zehn Level, lies die mal durch und sag mir, wo du dich einordnest.

Nenne eine Zahl zwischen 1 und 10.

Nenne eine Zahl zwischen 1 und 10 und dann machen wir von da an.

Einerseits dient das natürlich der Strukturierung, weil dann kann man sagen, so, okay, Level bla bla bla mach das und das, Level bla bla bla, mach das und das, dann lese ich mir jetzt das Level durch und kann mich mit dem Thema beschäftigen.

Das ist auch wichtig für Leute, die wiederkommen, weil wir uns dann nicht merken müssen, woher haben wir gemacht, sondern auf jeden Fall wissen die Leute das selber.

Das ist natürlich unsere Bequemlichkeit.

Also, ich glaube, das Repo hat offiziell zehn Level.

Angefangen bei wie führe ich Code in Python aus.

Dann, was ist eine Variable?

Was ist eine Variable?

Wie weise ich eine Variable zu?

Was sind Zahlen?

Was sind Zahlen?

Ja, wobei das geht, glaube ich, in die Zahlentheorie rein, das wollen wir, glaube ich, nicht.

Ganz einfach, Zahlen müssen.

Das sind

Mengen und.

Äquivalenzklassengleichmächtiger Mengen.

Ja, genau, bitte.

Ja, das geht dann über If-Bedingungen, Schleifen, Funktionen, Rekursionen.

Konsolenanwendungen.

Das ist ein neues Kapitel, das wir eingeschoben haben, weil wir dachten, wenn wir direkt mit Objektorientierung ankommen, dann sind die meisten Leute ein bisschen überrascht.

Und uns wäre es lieber, wenn man Sachen dann zu dem Zeitpunkt mal praktisch anwenden könnte.

Ja.

Das ist ja auch eine Stärke von Python, dass man, dass die Objektorientierung zwar da ist und auch alles in Python ein Objekt ist, aber du musst sie eben nicht verwenden.

Also du kannst in Python auch komplett ohne Klassen arbeiten.

Und das hatte der Schi tatsächlich einmal erzählt, dass er, wenn er mit Klassen arbeitet, eben nur objektorientiert, weil die anderen Arten von Klassen, die es da gibt, braucht man ja nicht.

Uns fragen halt immer Leute, wofür brauche ich denn jetzt diese Objektorientierung?

Wir können das nicht beantworten, weil das geht meistens auch ohne.

Ja.

Ja gut, also nach Objektorientierung machen wir dann noch Generatoren und sowas.

Assert Yield, wir haben dann ein Beispiel für eine grafische Anwendung mit QT, glaube ich.

Und irgendwie so eine so eine Whisky-Sache mit Werkzeug.

Die haben wir noch niemandem gezeigt, weil Leute sind nicht lange noch gekommen.

Ist natürlich auch nicht.

Die kennt selber auch noch nicht, die Whiskey mit Merkmeldung.

Der musste mal wieder kommen.

Ist geplant.

Ich bewundere übrigens auch, wie du die Markdown-Seite im Kopf auswendig kannst.

Naja, es sind jetzt drei Jahre.

Das hat sich nicht so groß gegangen seitdem.

Aber du hast die Witze entfernt.

Es gibt da so eine Geschichte.

Wir saßen mal in einem Zug nach Hamburg und es war ein bisschen langweilig.

Und dann haben wir zu Kapitel 5,5 einen Text geschrieben, den man nur noch in der Wiki History findet.

Ich glaube, das reicht jetzt.

Okay.

Ja, das ging, Level 5.5 ging damals um Themen, die in den bisherigen Leveln keinen Platz gefunden haben.

Ist Kapitel 5.5 sowas wie Gleis 9,5

oder so ein bisschen.

Ein bisschen.

Sie wollten halt noch Themen unterbringen, über die wir bisher nicht gesprochen haben, weil entweder passten die nicht, die wären zu weit gegangen, oder sie hätten den Fortschritt so ein bisschen.

Wir gehen doch immer zu weit.

Genau.

Sie hätten den Fortschritt so ein bisschen aufgehalten und das waren dann hauptsächlich Metathemen, die jetzt nicht zwingend direkt was mit Python zu tun haben, sondern mehr, da ging es dann darum, welchen Texteditor benutze ich, wie mache ich das mit Git.

Wie schreibe ich am besten Doku?

Wie schreibe ich Doku?

Mir fällt übrigens ein, wir sollten noch ein Kapitel zu Tests einführen.

Ja, wir sollten nicht nur erwähnen, dass sie wichtig sind, sondern uns trotzdem mal selber angucken, wie das überhaupt geht.

Also ich habe das meiste, was ich bei Python meist tatsächlich da habe und dann ich gelernt habe, es ist einer Leuten beibringe, weil man da immer noch so Sachen merkt, sieht, wo man merkt, oh, das weiß ich doch eigentlich gar nicht so, wie das mit Detail funktioniert.

Das fällt mir immer wieder auf, dass wir dann auch, da wir gegenseitig uns den Ball zuspielen und doofe Fragen stellen und auch Grenzfälle austesten, dass ich jeden Abend, wo ich anderen was beibringe, auch selber sehr viel mitnehme.

Das den Leuten, die da sitzen, dann doch nicht so wichtig ist.

Ja, das stimmt.

Ja, aber es gibt halt auch Leute, die Interesse an diesen ganzen Details haben.

Und ihr habt auf jeden Fall vollkommen recht, dass dieses Lernen einfach großartig ist, irgendwie, um tiefer einzusteigen in das Thema.

Habe ich übrigens auch gemacht, also ganz am Anfang, obwohl ich noch nicht so viel selber konnte,

aber das,

was ich konnte, konnte man schon Kleinkindern beibringen und die haben sich sehr darüber gefreut.

Und haben tatsächlich dann auch ihre ersten Programme schreiben konnten.

Das ist echt super.

Und dadurch sind halt die Basics dann irgendwann wirklich feste.

Das ist vielleicht gar nicht so unwichtig.

Ich glaube auch, dass Python eine sehr gute Programmiersprache ist, um quasi als kompletter Anfänger als erste Programmiersprache Python zu lernen.

Einerseits, weil es relativ wenig Einstiegshürden hat, die anderen Programmiersprachen bieten.

Es gibt ja diesen schönen Spruch, irgendwie Python ist wie Pseudocode, aber man kann ihn ausführen.

Ja, das und ihr hattet das, glaube ich, in eurer ersten Folge erwähnt, dass Python einfach ist und dadurch sehr gut für Anfänger geeignet ist.

Und ich finde, das ist auch so weit korrekt.

Ja, Pseudocode, den man ausführen kann, passt schon sehr gut.

Womit fangt ihr denn an, wenn ihr Leuten jetzt quasi sozusagen das so Python nahe bringen wollt?

Was wäre denn sozusagen euer erstes Beispiel oder so, was ihr.

Hello World natürlich.

Hello World natürlich, genau.

Das ist natürlich viel einfacher.

Ja, normalerweise fangen zeigen wir einfach auf dem großen Fernseher einen Interpreter und fangen an, Code zu schreiben.

Da kann man plant.

Da kein Plant für den Fernseher.

Ja, wir sitzen dann da an einer langen Tischreihe und einer sitzt meistens nah am Fernseher und zeigt dann auf BPython meistens Code.

Gerade für kürzere Sachen haben wir festgestellt, dass der Interpreter geeigneter ist, als wenn wir das in eine Datei schreiben würden und ausführen würden.

Natürlich könnte man das auch als UPython-Notebook machen.

Das wäre vielleicht sogar noch einen Schritt weiter.

Ich benutze manchmal in den höheren Leveln Hydrogen, das ist ein Admin-Plugin, wie Jupyter funktioniert, zahlenweise.

Wo das macht halt erst ab größeren Dateien auch irgendwie Sinn.

Am Anfang kann man das halt einfach neu eintippen.

Gerade auch, weil B-Python so einen Modus hat, wo du die gesamte Historien im Texteditor bearbeiten kannst und dann wieder ausführen kannst.

Und dann musst du es halt eigentlich nicht unbedingt speichern.

Und B-Python kommt uns natürlich da sehr entgegen.

Mit Autovervollständigen und Syntax-Halering, das ist schon echt cool.

Also, ja, es ist bunt.

Das B für bunt.

Ja, ja, das steht für Buntpython.

Weil das ist auch deutsche Sprache, das muss so.

Ja, und meistens in, ich glaube, spät höheren Leveln zeigen wir dann auch einfach die Codebeispiele, die wir geschrieben haben.

Aber gerade am Anfang, weil man im Interpreter auch deutlich besser auf Fragen eingehen kann, da kann ich dann einfach den, wenn mich, wenn ich gefragt werde, was ist denn, wenn ich das und das mache, kann ich das einfach direkt zeigen, als wenn ich das in eine Datei schreibe und dann den Commit, das wieder committen muss.

Wir wechseln dann meistens so bei Ifs und Schleifen.

Ja, weil da ist es dann irgendwann, dann hast du auch Verschachtelungen und sowas und dann wird es schwieriger, einfach nach oben zu drücken.

Ja.

Da wird es dann anstrengend irgendwie mit BPython.

Das könnte man tatsächlich wahrscheinlich im Jupyter Notebook machen.

Ja.

Aber dann hat man halt tatsächlich auch wieder erstmal so einen Webbrowser dazwischen und dann muss man dann, wenn

die Leute das nachvollziehen,

wenn die Leute das nachvollziehen wollen, wird es wieder schwerer.

Ja, es ist nicht so.

Jupyter habe ich immer gerne mal versucht, so zwischendurch anzutesten.

Das ist natürlich super nett, gerade wenn man so Graphen noch einbaut, weil man direkt die Auswirkungen von den Datentatz in diesen Graphen sehen kann.

Aber ansonsten fand es jetzt erstmal so ein bisschen anstrengend.

Aber vielleicht bin ich jetzt auch nicht wirklich drüber gestolpert.

Ja, also ich glaube, man hatte erst so richtig den, also oder für mich hat es halt dann richtig funktioniert, als ich gemerkt habe, dass ich mir damit eine Menge Zeit sparen kann, wenn man Schritte hat, also die irgendwie Daten laden oder Sachen, die lange laufen und wenn man dann irgendwie Fehler macht und dann nicht alles weg ist, sondern man halt den Fehler korrigieren kann und das dann nochmal die Zelle ausführt und das dann einfach weitergeht.

Das war dann so, wo ich mir dachte, so wow, das ist auch.

Ja, das ist halt so das, wofür ich das dann brauche.

Aber wenn ich jetzt zum Beispiel Webentwicklung mache, dann benutze ich das zwar auch, aber deutlich seltener.

Also eigentlich eher nur dann, wenn ich halt so viele Jobs habe, die eine Menge Zeugs berechnen.

Ja.

Aber nee, das ist schon ja auch nicht.

Wir sind ja gerade wieder bei der Umgebung.

Welchen benutzt ihr denn so privat dann?

Inwiefern Umgebung?

Wieso benutzt ihr überhaupt eine oder alles in der Shell?

Ich schreibe meinen Code mit der Nadel auf der Platte.

Also ich persönlich bin ein großer Fan von Atom, weil ich halt nicht nur Python benutze, sondern auch irgendwie für die Software, die wir im Dorf haben, die existiert.

Oder ob ich auch für die Uni diverse Programmiersprachen nutzen muss.

Und Atom kann ich halt Plugins für irgendwie alle Sprachen installieren und dann funktioniert das halt ähnlich.

Ich muss mir das nicht immer einzeln anschauen.

Ja, ich glaube, ich habe jetzt einmal alles ausprobiert.

Also am Anfang war es tatsächlich Gedit, der vorinstallierte Texteditor von GNOME.

Das hat auch gut funktioniert, weil hat halt Syntax-Highlighting hat und mehr brauchte ich da nicht.

Dann war so ein bisschen meine Sublime-Text-Seite.

Das hat jetzt auch nur ein bisschen mehr gemacht als GEdit.

Also ich konnte ja den Code auch im Editor direkt ausführen.

Sublime hat dann eine Python-Konsole aufgemacht.

Das hat auch gut funktioniert.

Dann habe ich auch Atom benutzt, auch mit Plugins, die mir dann zum Beispiel den Linter gemacht haben oder eine Python-Konsole.

Mittlerweile bin ich bei VS-Code angelangt.

Mit, ich glaube, ich weiß nicht, ob es da Plugins oder Add-ons heißt.

Jedenfalls ein Flag 8-Add-on, dass er mir direkt die Type-Annotations.

Oh ja, MyPy.

Ja, ich glaube, das ist.

Ich habe, glaube ich, nur das Flake 8 oder auch MyFile.

Das ist großartig, habe ich auch für mich entdeckt.

Und da kann man ja auch die Git-Verwaltung direkt eintauen.

Und man hat

so eine tolle Live-Share-Funktion, da kann man kollaborativ direkt arbeiten, als er ist man vor dem gleichen Rechner.

Geht in LTM auch alles.

Aber ja, also aktuell mein Workflow ist in der.

Das gibt mir im VI auch.

Und Screen-X und

so ein bisschen angestaubt.

Letztendlich sind wahrscheinlich alle Texteditoren irgendwie, aber wir scheinen alle nicht wirklich so eine Idee zu nutzen, sondern eher ein Texteditor mit irgendwie Zivil Plugins.

Ja, ich Pycharm habe ich installiert.

Ich starte es irgendwie jedes halbe Jahr mal und mache es dann direkt wieder zu.

Ich verwende es tatsächlich auch manchmal länger.

Wobei, ehrlich gesagt, eher Webstorm als Pycharm, also die gleiche Idee, aber für JavaScript.

Oder halt TypeScript in meinem Fall jetzt.

Ja, aber ich finde Pycharm auch schwer zu bedienen.

Also es ist halt schon auch coole Sachen, aber es ist halt irgendwie, es fühlt sich nicht so gut an wie ein richtiger Editor irgendwie.

Und ich meine, ja, selbst Atom, das ja im Grunde auch mehr so ein Browser mit irgendwie JavaScript und dann dem Editor in JavaScript in dem Browser ist, es fühlt sich halt viel irgendwie so agiler an als Python.

Ich weiß, was man da sagen muss, dass die bei Atom in den letzten zwei Jahren wirklich starker an der Performance gearbeitet haben.

Also wahrscheinlich auch dadurch bedingt, dass viele Leute auf Scot umgestiegen sind, weil es halt schneller war.

Atom ist wesentlich schneller geworden tatsächlich.

Ah, okay, muss ich vielleicht auch nochmal ausprobieren.

Ich finde,

in der Nick, das hat auch eben einen guten Punkt gebracht, dass eben, klar, wenn ich mit Python arbeite, gibt es wahrscheinlich nichts Besseres als Python, also keine umfassendere Lösung.

Gerade weil die Professional-Version auch noch sehr gute Interaktion sehr gute Interaktionen mit anderen Sachen, zum Beispiel Git oder Django liefert.

Nur gerade wenn ich in meinen Git-Repo nicht nur Python-Dateien, sondern eventuell noch eine Markdown-Datei oder ein Bild habe oder ganz andere Sachen, dann hilft mir PyCharm nicht, weil dann habe ich VS-Code und dann kann ich da die Code-Dateien öffnen, da kann ich die CSV-Datei ändern, da kann ich die readme.nd ändern, da kann ich mir das Bild angucken.

Alles in einem Programm, statt dass ich die Python-Datei in PyCharm bearbeite, die Markdown-Datei in meinen Markdown-Viewer, das Bild in meinen Bildbetrachter und die CSV-Datei in meinen Tabellenkalkulationen.

Also so am krassesten habe ich mich gefühlt tatsächlich, als ich mit Platur mal irgendwie so ein Diagramm gemacht habe, das dann halt in Admir auch direkt schreiben und dann live gerendert habe und das dann in Freaken eingebunden und schon recht cool.

Gerade für so Sachen, wo man eben nicht nur Codedateien im Repo hat, ist glaube ich so ein Texteditor mit Add-Ms die bessere Option.

Weil dann kann ich mir VS-Code und dann habe ich eben Autocompletion für Python und meinen Linter und mein MyPy und vielleicht dann noch ein Preview für Markdown-Dateien und der Bildbetrachter ist eingebaut.

Da habe ich dann alles in einem Programm, habe an der Seite die Ordnerübersicht und dann kann ich da durchgehen, habe das in einem Programm, zweites Fenster noch das Terminal und bin damit voll zufrieden.

Und die Einstiegshörte ist auch geringer.

Ich kann mir irgendwie Sublime installieren, die Datei öffnen und da kann ich direkt anfangen zu programmieren.

Ich muss mir nicht mehr nicht erstmal durch den Einstellungsdialog klicken, um rauszufinden, wie ich jetzt zoome oder so.

Das hatte ich funktioniert halt alles so, wie man es erwarten würde.

Das finde ich schon praktisch.

Das hatte ich, ähm, VS-Code habe ich jetzt erst seit neuen Dings, also vielleicht drei Monate.

Und da habe mich positiv überrascht, ich habe VS-Code geöffnet und wollte dann einfach meine Python-Datei ändern.

Und da hat er direkt mir vorgeschlagen, hier möchtest du nicht dieses Add-on installieren, dass dir die Autocompletion macht.

Und ich so, ja, gerne.

Hier wähle deinen Linter aus.

Ja, gerne.

Grace Yourself Linter als KMS.

Es ist sehr

user-centric, ne?

Natürlich.

Und ja, in meinem ESS-Feed lese ich dann auch hin und wieder, welche Neuerungen in VS-Code jetzt bezüglich Python kommen.

Und das sieht schon sehr gut aus.

Ich hatte, also das ist das einzig große Problem, was ich mal mit Atom hatte, ist, Atom konnte sehr spät so Type-Notations.

Das hatte bis irgendwie 1.25 oder so.

Wenn ein Pfeil eine Methodensignatur war, ist das ganze Highlighting kaputt gegangen.

Das war sehr witzig, weil das ja eigentlich schon seit Python 3 im Sprachstandard enthalten ist.

Und dann,

na, aber gut, ja.

Ich muss auch sagen, seitdem ich VS-Code mit einem direkt eingebauten Linter benutze.

Machst du weniger Fehler?

Nicht nur, sondern da benutze ich auch richtig gut die Type-Annotations und selbst wenn es irgendwie ein Skript von 50 Zeilen ist, dadurch, dass der mir darauf hinweist, wenn ich was falsch mache, benutze ich es häufiger.

Und das finde ich, das ist schon ein positiver Nebeneffekt, dass ich schöneren, dokumentierten Code schreibe.

Ja, bei so Type-Annotations waren wir uns am Anfang auch nicht sicher, wie wir das jetzt, das jetzt tatsächlich, sollen wir das zeigen, soll man das nicht zeigen?

Wir haben am Anfang so gemacht, dass wir die alte Syntax genommen haben, wo die Typen nicht bei den Variablen standen, sondern in Kommentaren dahinter.

Weil wir uns überlegt haben, wir wollen eigentlich, dass unsere Beispiele mit allen Python-Versionen laufen.

Zumindest mit allen Python 3-Versionen.

Also auch mit 3.4.

Also mit allen aktuell unterstützten Python 3-Versionen.

Aber wenn dann jetzt 3.4 irgendwann stirbt, dann können wir uns überlegen, ob wir das nicht vielleicht auf die neue Syntax ändern.

Ja.

Das ist natürlich auch so.

Gerade wenn man den Code für Einsteiger schreibt und nur sagt Python 3, dann muss man natürlich auch darauf achten, dass der Code kompatibel bleibt.

Wir hatten zum Glück noch niemanden, der damit zwei oder drei Dreh aufgetaucht ist.

Das ist einfach zu schwer zu installieren, das schafft sowieso keiner, äh, kein Anfänger.

Gibt es aber noch

zwei Sachen irgendwo?

Docker über Python Doppelpunkt 3.2.

Ja, also ich habe durchaus schon noch zum Beispiel, was mich irgendwie auch genervt hat beim Rooster eines Kunden, der hatte dessen aktuellste Version, war Python 3.3, was halt, das war auch bei Debian halt irgendwie eine Zeit lang, irgendwie so das, was halt dann dabei war.

Und ja, das ist halt halt schon schlimm.

Weil so 3.4 wäre echt gut gewesen.

Also wir sagen uns halt, wenn die Version im Moment noch supportet ist, dann versuchen wir auch die zu rennen.

Und es ist ja nur 3.4 im Moment noch als ältestes Mal.

Ja, insofern 3-4 sein.

Also für mich war so 3-4 die erste richtig gute Dreier-Version, die man vor allem nicht mehr so dauernd Sachen auf den Fuß gefallen hat.

Letztes Mal, weil es ein zwei über den Weg gelaufen, so im aktiven Betrieb.

Mir ehrlich gesagt schon ganz lange nicht mehr.

Also ich würde sagen, das müsste dann schon so wahrscheinlich 2000.

Na okay, was?

So lange ist das jetzt auch nicht hier.

2014, 15 gewesen.

Letzte Woche hat er sich ein Startup getroffen, die so einen Sensor betrieben haben auf Python 2-API-Basis.

Haben Sie noch ein Jahr Zeit?

Ich habe aber auch mittlerweile das Gefühl, dass Python 3 doch mittlerweile weit genug verbreitet ist, also dass Python 2 doch langsam stirbt.

Ja.

Also endlich

das Problem gelöst, keine zwei Sprachen mehr, sondern Progress.

Ja.

Sehr gut.

Weil Python 3 ist dann irgendwann nicht mehr Zukunft, sondern Gegenwart.

Wann kommt dann endlich Python 4?

Sollte es ja eigentlich gar nicht geben, wenn ich die Leute das verstanden habe.

Ich habe irgendwie einen Blogpost von 2015 gefunden, wo 2020 drin stand.

Aber das ist dann Python 342 oder so.

Glaube ich nicht.

Ich glaube es auch nicht neu.

Da stellt sich dann natürlich die Frage, ob man bei Python überhaupt eine 4 oder 3,141.

Wobei es gab doch, ich meine in den Ließenotes 237 oder so, gibt es irgendein Feature, dass Type Annotations als String betrachtet werden, wo steht, dass es im Moment Opt-in ist, irgendwie mit From Future Import, aber beiden 4 macht das dann als Standard.

Und dann habe ich mir gedacht.

Okay.

Das ist halt ja, das mit dem Annähern an so eine Zahl, das ist ja, das ist leider schon ein bisschen vergeben.

Ich glaube, Latech macht E und Tech macht Pi oder so, ne?

Oder?

Die nähern sich mit ihren Versionsnummern schon irgendwie.

Wenn sie bei Semfer bleiben würden, wäre ich da froh.

Ja, das wäre auch ganz gut.

Das ist ein bisschen, also, ja.

Ja, wenn man die Versionen nichts bedeuten, ist auch so ein bisschen schlecht, okay.

Kann auch jedes Jahr wieder hochzählen, dass wir irgendwann bei 2020 angekommen sind.

Wenn sich da nichts großartig ändert, warum nicht?

Verwirrt mich ja immer noch bei den Ubuntu-Versionen, die sich nach Buchstaben benennen und dann nach Z wieder bei A angefangen haben.

Ja, was hättest du erwartet, dass die irgendwie auf dem Modus bringen oder was?

Anderes Alphabet.

Ja, äh.

Was mich jetzt noch interessieren würde, also auch aus persönlichen Gründen, was wäre denn mit dem nächsten Level, also wenn ich jetzt so die ganzen Basics irgendwie so, wenigstens so ein bisschen verstanden habe, was würde ich denn als nächstes machen?

Also wir müssen uns ja nicht immer da sklavisch an unser Rahmenprogramm halten.

Das haben wir ja nur vorbereitet, damit wir notfall was haben.

Also wenn Leute irgendwie Fragen zu Themen haben, dann gehen wir da auch drauf ein.

Oder wenn die irgendwie Projekte haben oder sowas.

Projekt ist

vielleicht ein gutes Stichwort.

Das heißt, wenn man bei euch durch ist mit dem Tutorial, dann sollte man mit Projekten anfangen oder was würdet ihr empfehlen, um die Sprache so ein bisschen besser zu verstehen oder irgendwie so

Konzepte zu durchschauen?

Ich glaube, es ist tatsächlich ein sehr guter Ansatz, dass man, wenn man mit dem Programmieren anfängt und dann das Tutorial bei uns absolviert hat, das muss man nicht mal alle zehn Level sein, sondern das kann halt auch, ich glaube, mit Level 6 haben wir Funktionen abgearbeitet.

Ich glaube, es sind mehr als zehn Level.

Ich glaube, in Level 6 haben wir Funktionen abgearbeitet und dann, wenn man dann quasi ein Projekt hat, wenn man sich überlegt, ich möchte irgendwas mit Bildern machen, ich möchte irgendwas mit Zufall machen, ich möchte.

Oder mit Netzwerk oder?

Oder mit Netzwerk.

Das waren dann quasi anfängend, normalerweise fange ich immer so an, erstmal, wie macht man den Bandham-Algorithmus in Python, dann google ich das und dann gehe ich auf Stack Overflow und gucke ich mir an.

Ich muss ganz

kurz für unsere Hörerinnen erklären, was der Bandham-Algorithmus ist.

Das würde ich auch gerne wissen.

Das war ein Beispiel.

Damit habe ich mich irgendwann mal beschäftigt, ich weiß es selber nicht mehr.

In die Shownotes kommt das dann.

Ich kann es rausrufen.

Also wie gesagt, meistens hilft es, wenn man ein Projekt hat, das möchte man machen, und dann beschäftigt man sich daher mit Python, weil dann hat man ein Ziel und dann kann man gezielter Fragen stellen.

Ansonsten haben wir ja auch diese Situation, dass wenn Leute beim ersten Donnerstag im Monat zu uns kommen und beim zweiten Donnerstag im Monat zu uns kommen, dass die Personen da ja doch irgendwie was mitgenommen haben, hoffentlich.

Und dann kann man auch zum dritten Donnerstag im Monat kommen und dann sind wir nicht mehr da und dann können wir sich da jemand anders tun.

Aber genau, wenn ihr sagt, ihr macht dann Funktionen, wie tief geht denn das eigentlich sozusagen?

Wir zum Rekursionslimit.

Okay.

Und da vorhin

das Ritter gefolgt.

Aber macht ihr auch so Dekoratoren dann noch an Funktionen?

Ja, aber nicht in dem Level.

Das kommt später.

Erklärt ihr sowas, was Klutchers sind und solche Dinge.

Also das machen wir irgendwann.

Ich meine, da haben wir Level 8, 9 oder so, aber nicht dann.

Ja, ich glaube 8.

Ja, das ist immer eine schwierige Abwägung, weil man kann in die Themen viel tiefer reingehen.

Wir haben zum Beispiel am Anfang auch nur positionale Parameter gemacht und es wird später noch erweitert auf Keyword und sowas.

Weil man möchte natürlich auch nichts erwähnen, was man noch nicht erklärt hat.

Also zum Beispiel, wenn ich einen String habe, wenn ich ein Level 1 Strings durchgehe und dann sage, ja, ich kann feststellen, ob ein String Uppercase oder Lowercase ist, wenn ich String.isLower schreibe.

Dann müsste ich eigentlich erklären, ja, das ist jetzt eine Methode von String, die rufe ich auf den String auf.

Und dann bekommt es als ersten Parameter self.

Ja, aber ich persönlich finde es auch irgendwie doof zu sagen, das müsst ihr jetzt wissen, aber das machen wir später.

Was erwähnen es einfach gar nicht.

Aber ganz witzig da auch, weil ihr beide habt so ein bisschen andere Art und Weise, diese einfacheren Dinge zu erklären.

Und weil auch neue Leute dabei waren, hatte ich zum Beispiel so, dass ich einige Lektionen von jedem von euch einmal gehört habe.

Und das war sehr cool, weil ich dann bestimmte Sachen noch neu gelernt habe, die ich vorher noch nicht kannte.

Das ändert sich auch bei der gleichen Person jeden Monat.

Wir lernen ja auch dazu.

Ich behaupte, wir haben beide schon sehr viel daraus mitgenommen.

Ich finde es halt immer doof, wenn man Sachen nach hinten verschiebt und sagen muss, ja, also Print, das ist eine Funktion und was eine Funktion ist, das sagen wir später.

Oder auch in Programmierungen in der Uni in Java, ne?

Erstmal, das ist eine Klasse, das ist eine Funktion, das erklären wir später.

Ich finde das immer, wenn man was erwähnt, dann soll man es erklären.

Und klar, man kann die Printfunktion, man kann auch einfach hinnehmen, dass wenn ich da einen String reintruhe, dann wird er ausgedruckt.

Wir können ja Funktionsaufrufe auch machen, bevor wir selber Funktionen definieren.

Das ist ja kein Problem.

Man kann sagen, so, das ist eine Funktion, die bietet die Möglichkeit, einen Code abzuspeichern und wieder auszuführen.

Und wie man das selber definiert, machen wir später.

Aber gerade bei diesem String-Beispiel, dass man eben Funktionen hatte, die auf einen Swing aufgerufen werden und nicht mit einem String, das.

Es hat bisher auch zum Glück niemand gefragt, warum da ein Punkt steht.

Ja.

Oder das ist so eine Schwierigkeit, die es mit sich bringt, wenn man eben am Anfang Sachen erklären will, aber noch nicht zu sehr darauf eingehen möchte, warum das jetzt so ist.

Und wenn man dann also weitergekommen ist, dass man halt viele von diesen Konzepten verstanden hat und sein eigenes Projekt angefangen hat, dann ist halt die Frage, möchte man jedes Projekt dann komplett abschließen oder hat man in dem Projekt so schnell was gelernt, dass man direkt nächstes Mal.

Wie viele von euren Projekten habt ihr nicht fertig gemacht?

Alle werde ich irgendwann nochmal fertig machen, glaube ich.

Also das erste Projekt, mit dem ich angefangen habe, war irgendwie eine Verwaltung für einen Videorekorder.

Ich habe zu Hause so einen Festplattenrekorder, mit dem konnte ich irgendwie Dinge aus dem Fernsehen aufnehmen.

Und dann habe ich mir gedacht, das wäre ja total cool, wenn ich die dann irgendwie so sortieren könnte, irgendwie nach Staffel, Episode und sowas.

Es gibt da ja auch so Online-Datenbanken.

Und das war mein erstes Projekt und ich mache da alle zwei Jahre nochmal irgendwie so einen Commit.

Und bitte guckt es euch nicht auf GitHub an, das ist schrecklich.

Ja, ich glaube, ich habe auch noch auf meinen GitHub-Repo, in meinem GitHub-Account Karteileichen von Projekten, die ich mal angefangen habe, halbherzig irgendwann dann liegen lassen.

Da müsste ich, glaube ich, auch mal auskehren.

Hast du noch diesen einen YouTube-Client, der irgendwann einfach das Stacklimit erreicht, weil jeder Menüpunkt ein neuer Regressions ist?

Ja, das Programm gibt es noch.

Ich glaube, das funktioniert sogar noch, aber da habe ich halt seit Jahren nichts mehr gemacht.

Und ich nehme mir vor, das irgendwann zu tun, aber ja.

Man kann Repos ja auf GitHub mittlerweile auch archivieren, aber ich hatte bisher noch nie diese harte Entscheidung getroffen, es dann doch nicht mehr zu machen.

Nee, das genau.

Es gibt da mehrere Stunden.

Also bei mir gibt es auch, ich habe ganz, ich war auch gut, ich weiß nicht genau, ich habe vielleicht so 60 GitHub-Prepos oder sowas.

Ich sammle die nicht, aber im Verlauf der Zeit passiert das irgendwie und dann gibt es halt unterschiedliche Stadien von, in denen sich Projekte befinden können.

Also tatsächlich, ich habe auch noch nie ein Git-Prepo gelöscht oder ein Projekt wirklich komplett wieder verschwinden lassen.

Aber es gibt dann halt welche, dann, wenn ich dann schon mal eine Domain registriere, dann ist es schon ernster.

Oh ja.

Also ich habe halt wohl Projekte, die ziemlich gut funktionieren, zu denen ich aber keine Doku habe.

Und ich habe welche, wo ich eigentlich nur das Konzept habe und noch keine Software.

Es gibt so eins, da habe ich eine Domain, da zahle ich jedes Jahr Geld für und da habe ich keine Software für.

Sehr gut.

Bei einem Projekt, das hatte ich, das ist mittlerweile jetzt auch drei Jahre alt, da ging es um Gruppenoptimierung und ich hatte das angefangen und da hatte ich erst unglaublich viel Zeit investiert, mir viel zu viele Gedanken zu machen, okay, wie mache ich das jetzt?

Das war doch dein erstes grafisches Programm, oder?

Ja, das war für mich aus vielerlei Hinsicht interessant, weil ich da einerseits einmal so richtig mit Objektorientierung gearbeitet habe.

Also so einmal komplett Objektorientierung und Grafik und ich quasi daran auch selber Dinge lernen wollte.

Daran habe ich dann auch Git viel besser kennengelernt.

Konflikte mit sich selbst ist auch etwas, was man vergabt haben sollte.

Das muss man einfach mal gemacht haben.

And ich glaube, nach ein paar Monaten, wo ich da wirklich hochkonzentriert dabei geblieben bin, bin ich dann in so einer Sackgasse gelaufen, dass es einfach nicht mehr funktionierte, dann habe ich das liegen gelassen, dann habe ich irgendwann wieder angefangen, die Codebasis überarbeitet und dann lief es wieder und dann habe ich das wieder ein bisschen liegen lassen und dann habe ich da irgendwann mit weitergemacht und mittlerweile bin ich da sogar auf einem relativ guten Weg.

Aber mittlerweile ist bei mir im Allgemeinen der Workflow auch so, dass ich zwar Projekte lokal anlege, auch als Git-Repo, aber dann erst auf meinen GitHub-Account hochlade, wenn das quasi so weit ist, dass ich es der Öffentlichkeit zeigen möchte.

Ja, also ich habe das so, dass ich alle, also dass ich eigentlich immer nur ein oder ein Projekt habe, an dem ich aktuell arbeite und das halt irgendwie so mal entweder bei mir das eine oder mal langweilig wird oder durch so andere Faktoren irgendwie wenig Zeit oder sowas.

Oder Leute sprechen nicht mal an mit, hey, was ist denn eigentlich geworden aus?

Dass ich das dann so irgendwie einmal im Monat wechsle, was ich gerade aktuell mache.

Ja, ich glaube, bei mir ist das relativ sprunghaft.

Also ich habe dieses große Projekt mit der Ruppenoptimierung, wo ich halt immer, wenn ich mal wieder Zeit und Lust dran habe, weiterarbeite.

Da habe ich es jetzt mittlerweile auch ganz gut mit der Doku hinbekommen, dass ich auch vier Monate später noch weiß, wo ich war und was mein letzter Stand ist.

Du auch Tests.

Tatsächlich habe ich teilweise Tests.

100% Coverage.

Die werde ich niemals erreichen, aber für die Objektorientierung, die da zugrunde liegt, sind Tests sogar schon fertig.

Die führe ich auch hin und wieder aus.

Aber meistens ist es bei meinen Projekten eher sprunghaft, dass ich halt kleinere Projekte habe.

Das sind dann meistens auch nur so ein paar hundert Zeilen Code, wo ich entweder spontan die Idee dazu hatte oder da hatte mich wer gefragt und ich habe das einfach mal ausgetestet oder wir hatten da Donnerstag drüber gesprochen und ich wollte da quasi noch weitergehen.

Das hatte ich jetzt letztens.

Da habe ich was mit Bildern gemacht.

Also aber du hast noch früher immer direkt bei GitHub direkt hochgeladen, das ist interessant.

Also ich habe jetzt so ein paar Sachen entdeckt, Bitbucket kennt ihr ja bestimmt alle und Azure, da gibt es ja jetzt ja auch die Möglichkeit, private Repositories unbegrenzt anzulegen.

Ja, dafür habe ich mir einen extra GitLab-Account gemacht, damit ich ein privates Repo anlegen kann.

Ja, aber das gibt es jetzt bei GitHub auch.

Das war früher kostenpflichtig.

Also das ist jetzt neu, das ist nicht mehr kostenpflichtig.

Nee, nee.

Achso.

Da wollte ich dann auch überlegen, ob ich mein Gruppenoptimierungsrepo einmal auf GitHub hochlade und eventuell dann sogar ein öffentliches Repo, weil es mittlerweile doch ganz schön ansehnlich ist.

Aber es gibt bei diesen kostenlosen privaten Repos auf GitHub irgendwie Einschränkungen.

Aber du kannst, glaube ich, irgendwie dann keine Leute hinzufügen oder sowas, die damit arbeiten können.

Das kostet weiterhin Geld.

Ja gut, irgendwie soll GitHub ja auch Geld verdienen.

Also finde ich schon okay.

Aber Gruppenoptimierung, das.

Ich glaube, nicht mathematische, oder?

Nein, nein, nicht mathematische Gruppen.

So so Teamzuteilung und Teilnehmersystem.

Ja, Teamzuteilung.

Hatte ich mir dann in der Mitte der Entwicklung dann auch überlegt, weise ich hier Menschen werten zu, ob das noch moralisch vertretbar ist.

Man muss wissen, Dodo macht Jugendarbeit.

Ja, ja, ich mache das mit der Jugendarbeit und da ist es immer schwierig, die Teams fert zu gestalten.

Also irgendwelche Sensorenarbeit übernehmen lassen bei den Bewertungen.

Ja, da musste ich mir dann auch.

Zum Glück funktioniert das Programm auch mit beliebigen Attributen.

Also die sind nicht so tief eingebaut, dass ich die nicht jederzeit ändern könnte.

Da musste ich mir dann erstmal Gedanken machen, welche Attribute ich nehmen kann.

Aber da habe ich dann auch gesehen, dass ich das gar nicht kann, dass ich quasi ein Projekt von vornherein aus plane und dann irgendwann anfange.

Das war da am Anfang mein Fehler, dass ich mir viel zu viele Gedanken gemacht habe, wie ich das dokumentiere, wie ich das strukturiere.

Und es hat deutlich besser geklappt, als ich dann irgendwann einmal die Codebasis komplett umgeworfen habe und direkt angefangen habe, Code zu schreiben und danach zu dokumentieren, was ich da gemacht habe, als erst zu schreiben, okay, ich habe hier ein Player-Objekt und dann habe ich ein Klassenobjekt, äh, ein Team-Objekt und dann müssen die so und so miteinander interagieren.

Da hat es mir tatsächlich besser getan, einfach anzufangen, Code zu schreiben, dann ein bisschen zu dokumentieren, dann weiterzuschreiben.

So ein bisschen Agile Hands-On.

Das kannst du auch bestätigen, jochen, ja?

Ja, mir fällt das auch deutlich leichter, wenn ich das so mache.

Also ich meine, es gibt wahrscheinlich auch einfach unterschiedliche Arten von Leuten, denen unterschiedliche Dinge leicht oder schwer fallen.

Aber das, was man ja sozusagen erzählt bekommt, ist das irgendwie der Weg, wie es eigentlich sein sollte, irgendwie top-down.

Man macht irgendwie Architektur und überlegt sich, wie Dinge so funktionieren sollen.

Aber von der Klasse

planen und dann füllt man das sozusagen nur noch aus.

Bis zu irgendwie, keine Ahnung, wenn dann ein Konzern, jetzt habe ich mal irgendwann von Siemens gehört, wo es dann irgendwie gibt es dann irgendwie die Informatiker, die dann halt sich die Architektur überlegen oder UML-Diagramme malen, dann gibt es halt Programmierer, die dann halt die Funktionssignaturen ausfüllen.

Es gibt ja auch so Tools, die dir aus UML-Diagrammen dann automatisch Code erzeugen.

Das ist aber ein bisschen eklig.

Also aufgrund der meiner eigenen Erfahrung kann ich mir sehr schwer vorstellen, dass das irgendwie zu einem guten Ergebnis führt.

Aber es

ist das Problem der Digitalisierung, oder?

Dass halt alles völlig überplant ist und dann ändert sich die Umwelt viel schneller, als der Plan noch aktuell ist.

Und dann ist der ganze Aufwand, den man fürs Plan betrieben hat, erstens dahin und man ist im Projekt noch nicht so weit.

Man hat noch keine Traction, wie man das schön sagte, bekommen irgendwo.

Aber andererseits sollte man durchaus schon so ein Konzept haben, was man eigentlich machen möchte.

Ja, auf Spiel anwenden.

Aber das muss ja nicht komplett ausformulieren.

Nee, nee, nee.

Es reicht ja auch, wenn du weißt, was du vorhast, aber wenn du das da ausformulierst, ist der Wille, sich an genau dieses Konzept zu halten, größer, als wenn du einfach nur ein Konzept im Kopf hast und dann, oder das kann auch grob ausformuliert sein, aber ich hatte halt versucht, das relativ stark und streng auszuformulieren und dann habe ich festgestellt, dass ich beim tatsächlichen Schreiben des Codes an Probleme stoße, die ich vorher einfach nicht beda

cht habe, die dann, wo ich mein Konzept ändern müsste, und da habe ich dann nicht versucht, das Konzept zu ändern, sondern den Code und das hat halt nicht geklappt, bis ich dann irgendwann eben das mit dem Konzept gelassen habe und direkt angefangen habe, Code zu schreiben, das klappte dann deutlich besser.

Ja, also mir geht das oft tatsächlich so, dass man die Abstraktionen, die man braucht, um das Ganze strukturieren, weil Struktur sollte es dann am Schluss ja vielleicht schon

haben, erst

einfallen, wenn man das implementiert, weil viele Dinge, die wichtig sind, man gar nicht weiß, bevor man es nicht gemacht hat.

Und dann erst, wenn man es, wenn man es hinschreibt, merkt man also, oh, das ist aber ganz wichtig, dass und dieses und dieses Ding, die vorher, wo ich vorher gedacht hätte, die wären gar nicht gleich, die sind aber eigentlich fast das gleiche.

Dann kann ich die dann hier zusammenfassen und dann kann es sein, dass da irgendwie auch ein elegantes Konzept oder so draus entsteht.

Aber erst ja so im Nachhinein, wenn man das Problem wirklich verstanden hat.

Aber um

das Problem wirklich zu verstehen, muss man irgendwie das schon programmiert haben.

Aber gerade so, wenn man, wenn man mit großen zeitlichen Abständen an einem Projekt arbeitet, finde ich es persönlich wichtig, auch sich so Sachen aufzuschreiben, weil ich es ansonsten einfach vergesse.

Und ansonsten, was ich nicht, also gerade außer Software, die ja noch tatsächlich Leute nutzen, also die ich nicht nur für mich selbst schreibe, finde ich das auch irgendwie wichtig, das ein bisschen zu dokumentieren.

Weil so auch wegen dem Busfaktor und sowas.

Also es wäre halt gut, wenn ich das nicht nur beim Kopf habe, sondern es im Notfall auch andere Leute machen können.

Ja, kleine To-Do-Liste vielleicht, ich weiß nicht, wird das dann schon viel sagen können.

GitHub-Issues.

Wie macht ihr Dokumentation

sozusagen in euren Projekten?

Zu wenig?

Zu wenig, ja.

Das Gruppenoptimierungsprojekt war jetzt das erste, wo ich wirklich Dokumentation gut angelegt habe.

Da habe ich halt eine Weadme-Datei, die so das Grobe umfasst und dann zu bestimmten Themen.

Ich glaube, ich habe eine GUI.md, die eben beschreibt, wie man die GUI benutzen soll und wie die so aufgebaut ist mit Mockup-Bildern und so.

Dann habe ich eine Klassen.md, die beschreibt, welche Klasse welches Objekt liefert und was die tun sollen, was die darstellen, wie die miteinander interagieren.

Und ich glaube, ich habe noch eine Backend.md, die beschreibt, welche Funktionen in der Backend.pi tatsächlich die Berechnung durchführen.

Ja.

Und in der Main.pi werden einfach GUI und Backend zusammengeführt.

Ich habe kurz, ganz wichtig ist irgendwie Sphinx oder sowas.

Dokumentiert.

Also ich benutze da auch tatsächlich Sphinx.

Also das Markdown, wird das dann irgendwie noch in was anderes verwandelt oder?

Nö, ich nehme Ruhe Markdown-Dateien.

Genau, weil, ähm, ja, nee, was ich normalerweise mache, aber also ich habe auch schon überlegt, nicht vielleicht komplett Markdown verwenden das Richtige wäre, aber was ich momentan verwende, ist halt Restructured Text als sozusagen Format für Dokumentation und dann Sphinx als sozusagen Renderer, irgendwie, der dann halt hinterher entweder eine Webseite ausspuckt oder ein PDF oder sonst irgendwas.

Und da nehme ich dann immer noch dieses ReadThe Docs-Theme dazu.

Es gibt so eine Seite irgendwie, das ist eigentlich ganz hübsch und dann, wenn man das mit dieses Theme mit installiert, dann sieht die generierte Dokumentation halt hinterher genauso aus und man kann sie auch automatisch irgendwie direkt auf ReadThe Docs irgendwie hochladen, wenn man jetzt da in GitHub so einen Hook aktiviert.

Ich glaube, sogar bei Sphinx aus seiner Dokumentation an den einzelnen Funktionen und Methoden dran, also aus den Doc-Strings, die erstellen lassen.

Kann man auch, genau, man kann dann halt Sachen, so API-Dokumentationen und ja, das kann man automatisch erstellen lassen.

Ist aber die Frage, wie hilfreich das ist,

weil, naja

gut, das steht ja auch schon im Code und ja kann man machen, aber weiß ich jetzt nicht, fand ich jetzt bisher nie so wirklich hilfreich.

Ich meine, wenn man jetzt natürlich wahnsinnig viel Dokumentation in Kommentare reingeschrieben hat, dann macht das vielleicht schon Sinn.

Gerade auch bei so Live, wo sich dann dann deute überlegen, wie rufe ich jetzt die Funktion tatsächlich auf?

Ja, was von Achtes?

Das ist tatsächlich gerade so die Hürde, vor der ich jetzt so ein bisschen noch stehe.

Wenn ich jetzt an meine Projekte denke, ich habe dann irgendwie eine fremde Bibliothek, die ich benutze, sei es jetzt irgendwie QT oder irgendwie sowas.

Und ich verstehe jetzt nicht, wie ich was Neues da machen kann.

Wenn ich eine Idee habe, die jetzt nicht direkt in den Klassen vorhanden ist und ich muss das irgendwie selber generieren, dann habe ich da eine Dokumentation, einen C-Code mit den Funktionensaufrufen, die da möglich sind.

Und wenn ich mir jetzt irgendwie abstrakt überlegen soll, wie ich jetzt den Schritt weiterkomme, das fällt mir so ein bisschen schwer.

Also, wie kann ich jetzt ein abstraktes Modell in meinem Kopf erzeugen, das ich noch nie ich kenne?

Whiteboard.

Ja, tatsächlich eins,

niemand schenken.

Also auch malen, sagst du.

Und dann in kleine Teile

zu liegen.

Also malen hilft doch ziemlich stark, finde ich.

Dann so Sachen auch besser vorstellen kann.

Okay.

Kann ich nur bestätigen, ich habe zwar auch ein Whiteboard, aber einerseits.

Ich habe zu Hause leider keins, aber wir haben ja genug davon im Dorf.

Ja, mein Whiteboard hängt leider zu weit vom Schrank weg.

Vom Schreibtisch weg.

Was ich dann mache, ich nehme dann noch ganz altmodisch Zettel und Papier und.

Ich nehme es leider auch nichts.

Also nicht in Kaltfreich war ich das.

Also Schmierzettel, meistens die Rückseite von irgendeinem Fehldruck und nehme dann Bleistift und male das auf.

Weil ich habe tatsächlich festgestellt, dass ich mich so deutlich besser mir Sachen visualisieren kann.

Wahrscheinlich würde das auch mit einem Grafik-Tablet geben, aber dafür müsste man hier Geld aufgeben.

Grafiktablets fände ich cool, aber ich habe bisher noch keins gekauft.

Tatsächlich für das Gruppenoptimierungsprogramm bin ich einmal, da hatte ich, da ging es um den Algorithmus, der tatsächlich die Optimierung macht.

Teilt die Teams nochmal auf und ist an einer Stelle ein bisschen rekursiv und so.

Und dann habe ich tatsächlich ganz viel Papier genommen und Schnipsel erstellt, auf die ich die Sachen draufgeschrieben habe.

So hier ist mein Player-Schnipsel und hier ist mein Teamschnipsel.

Und dann habe ich einen weitere Schnipsel genommen, die wie Pfeile aussahen.

Dann habe ich den Teppich zur Seite gerollt, das alles auf den Boden ausgelegt, ein Foto von mir macht.

Und seitdem habe ich im Repo ein Foto von Schnipseln auf dem Boden.

Da bräuchte man halt auch Platz auf dem Boden, ne?

Ja, da der positive Nebeneffekt war, der Boden ist jetzt auch gesaugt.

Aber seitdem habe ich im Repo ein Bild von Zetteln auf dem Boden und tatsächlich ist das gar nicht so doof.

Ich hätte es natürlich auch mit dem Grafik-Tablet schneller hingekriegt.

Aber.

Ja, nee, ich mache auch oft dann tatsächlich Fotos von irgendwelchen Dingen, die ich auf dem Zettel gemalt habe, weil das halt irgendwie schneller geht, als wenn man da.

Sie haben bei dir per Machine Learning automatisch getaggt und in den richtigen Ordnungen.

Das ist alles Handarbeit, aber was ich auch faszinierend finde, ist, dass ich, ich weiß nicht genau, warum, ich wollte eigentlich das Papier immer loswerden, aber irgendwie, das kann ja auch sein, dass das irgendwie so eine ja, so historisch irgendwie noch so ist, dass irgendwie, wenn ich Sachen aufschreibe, es kommt, ich hab, also meiner Ansicht nach ist es gar nicht so wichtig, was man sich aufschreibt, sondern allein das vom Papier sitzen und einem Stifter irgendwie was drauf rummachen, das hilft einem schon irgendwie, oder meinem Gehirn irgendwie offenbar dabei,

irgendwie im richtigen Modus zu operieren.

Und wenn ich das auf einem Tablet mache, was ich halt auch habe, dann funktioniert das irgendwie nicht.

Oder wenn ich auf einer Tastatur sitze.

Also wenn ich irgendwie tippe, ist es was anderes, als wenn ich das auf einem Zettel irgendwie aufschreibe.

Ich habe keine Ahnung, woran das liegt, ist irgendwie komisch.

Also bei mir funktioniert das tatsächlich auch ganz gut mit Textdateien.

Es ist halt nur, dass ich dann sonst nichts habe.

Also ich mache halt dann wirklich auch den Bildschirm frei und gucke halt, dass ich wirklich nur das habe, was ich schreibe.

Der Sehenmodus.

Und dann geht das eigentlich auch relativ gut, finde ich.

Vielleicht ist er aber witzig mit den Zeichnen.

Also ich habe auch

ein bisschen das

Gefühl, dass das wirklich hilft.

Vielleicht benutzt man andere Gehirnteile oder sowas und wird dann neu kreativ.

Oder auch, wenn ich gerade nicht Hermrechner bin, kann ich nicht Twitter aufmachen auf dem Whiteboard.

Ich kann mir vorstellen, dass es eine Kombination daraus ist, dass man einerseits weniger abgelenkt ist, dass andererseits, was weiß ich, vielleicht hängt es auch damit zusammen, dass wir aus der Schule Studium noch gewohnt sind, wenn wir was auf Papier schreiben, dann konzentrieren wir uns darauf.

Ich hasse Papier und Papier hast du nicht.

Und wenn wir vom Rechner sitzen, haben wir da ganz andere Reize, die auf uns zukommen.

Also ich kann das auch vollkommen nachvollziehen, was ihr sagt.

Also meistens brauche ich da auch Stift und Papier, weil Textdateien habe ich versucht, aber meistens kann ich in Textdateien das nicht so gut ausformulieren, wie wenn ich mir ein Schaubild aufs Papier male.

Ja, gerade so Pfeile und sowas und Kästen sind schwierig in Textdateien, ja.

Meistens brauche ich es dann ein bisschen grafisch, weil ich mir, was weiß ich, wenn ich mir, ja, jetzt fehlt mir ein Beispiel, meistens nehme ich dann kleine Grafiken, die ich mir dann aufs Papier zeichne, um mir das zu visualisieren.

Und ich finde, das klappt deutlich besser, als wenn ich das versuche auszuformulieren.

Was würdet ihr denn machen, wenn ihr gar nicht mehr weiterkommt?

Also ich habe das auch schon ein paar Mal gehabt, dann, keine Ahnung, weiß nicht, wie es geht.

Also wenn dann doof, also dann ist dann da so eine Wand, dann kommt man nicht einfach drüber.

Und was würdet ihr empfehlen?

Wie sollte man da dann rangehen?

Schlafen oder irgendwas völlig anderes machen.

Also teilweise kommen die Ideen dann irgendwie auf dem Klo oder unter der Dusche, Abend im Bettbahn.

Drüber schlafen, davon ablenken, was anderes machen, ist generell häufig führt das zu was, weil ich weiß nicht wieso, aber wie gesagt, mir fielen Sachen auch unter der Dusche ein, auf dem Weg ins Bett und dann dachte ich, ah nee, jetzt nochmal aufstehen.

Was mir auch geholfen hat, dass ich mich von dem Gedanken gelöst habe, dass es jetzt schlecht ist, wenn ich was lösche.

Also ich habe eine Version Verwaltung, das heißt, ich kann auch einfach mal die letzten fünf Commits zurück rückgängig machen und neu anfangen.

Also darf man.

Ich muss die Funktion nicht schrittweise neu schreiben, ich kann jetzt löschen und neu schreiben.

Ich gebe die alte Version noch.

Man darf auch ruhig mal 100 Zeilen Code auf einmal löschen und neu schreiben.

Nicht jeden Tag.

Nicht jeden Tag, weil irgendwo einen Fortschritt muss es auch geben.

Aber dann kann man beruhigt auch mal größere Mengen Code löschen und neu schreiben.

Meistens hilft das einem schneller, als wenn man versucht, alte Strukturen noch irgendwie zu laufen zu kriegen.

Weil man dann viel eher noch Sachen hinterfragt, die man vorher einfach akzeptiert hat.

Sozialkritische Kommentar des Tanz.

Ja.

Ansonsten Wapperducking ist natürlich auch sinnvoll, wenn ich nicht alleine vor meinen Code sitze und frage, warum der die ganze Zeit einen Fehler wirft oder warum er nicht das tut, was er machen soll.

Gerade semantische Fehler sind halt da schwieriger, wenn ich dann einfach jemanden anderen erkläre, so, also das Programm macht das und das.

Und dann stellt der mir Fragen und wenn ich die Fragen nicht beantworten kann, dann lerne ich da drauf.

Oder auch Doku schreiben.

Das ist so ein bisschen quasi Rubberducking mit sich selbst.

Und da fällt mir das dann auch teilweise auf.

Allein schon, weil man dadurch eine andere Blickweise auf das Problem bekommt.

Und das hilft einem meistens.

Rubberducking-Gummientin?

Ja.

Stell dir vor, du erzählst es einer Gummientin.

Genau, ich kenne das als Rubberduck-Debugging, sozusagen, ja genau.

Man debuggt dadurch, dass man einer Gummiente erzählt, was da eigentlich passieren sollte.

Und dann, wenn man das zehn Minuten, also es kommt aus der Erfahrung, dass man normalerweise anfängt, das irgendwelchen Leuten zu erzählen und die dann irgendwie alle 30 Sekunden sagen, so ja, aber ich habe keine Ahnung.

Und das muss man dann ignorieren und dann nach irgendwie zehn Minuten sagt man sie, ah, okay, ich weiß, worum es schief geht, ach Mist.

Das kommt halt immer auf

die Leute an.

Also wenn du genug Leute hast, die sich für ähnliche Dinge interessieren und noch Zeit haben, das wirklich spannend finden, dann geht das auch mit echten Menschen und nicht um mit Gummienten.

Vielleicht geht es auch sogar schneller, aber es geht halt auch mit Gummienten.

Ja, genau.

Und das ist halt das Faszinierende.

Irgendeine Art von einer Gummienten, die nicht irgendwo bei mir über diesen Jahr.

Es gibt tatsächlich Firmen, die so Gummienten als Werbegeschenke genau dafür verteilen.

Meistens ist es ja so, dass man tatsächlich nicht zu doof ist, sondern irgendeinen irgendetwas nicht bedacht hat.

Die Fehler sind meistens döfer als man selber.

Ja, was weiß ich, da hast du dann irgendwie eine Klammer vergessen und auf einmal ist das kein Tuppel, sondern sonst noch was.

Oh ja, ich habe mal ziemlich viel Zeit damit verschwendet, weil ich einen Tuppel haben wollte mit einem Element und dann eine runde Klammer drum gemacht habe und es war dann kein Tuppel, sondern es fehlt ein Komma.

Ja, wie gesagt, meistens sind es eher die doofen Fehler, die am längsten, die man am längsten sucht, weil es dann ja auch in Ordnung aussieht, wenn du drauf guckst.

Genau.

Ja.

Naja, da gibt es schon.

Aber das finde ich auch interessant, das ist auch vielleicht etwas, das halt irgendwie so den, wenn man die Tätigkeit beim Programmieren unterscheidet von anderen Geschichten.

Man ist ja als, ich glaube, das ist tatsächlich irgendwie ein bisschen was Besonderes, dass man, wenn man, wenn man programmiert, ist man halt irgendwie die ganze Zeit frustriert darüber, dass irgendwie Dinge nicht gehen.

Weil alles, was geht, das geht ja super schnell und ist super schnell automatisiert.

Und man ist immer eigentlich an dem Punkt, wo was nicht geht.

Und das ist, glaube ich, bei anderen Leuten nicht so.

Also ich meine, wenn ich jetzt irgendwie, keine Ahnung, wenn ich einen Garten umgrabe oder wenn ich irgendwie so Dinge, dann habe ich immer wieder Phasen, wo ich weiß, naja gut, das geht jetzt so eine halbe Stunde, weil das muss das aber, ich weiß, wie das geht, ich mache das jetzt einfach mal eine halbe Stunde lang.

Zum Beispiel beim Kochen oder so, dann schnübbel ich irgendwas.

Man hat nicht die ganze Zeit das Problem, da wirklich von einem harten Ding, was man nicht versteht, zu stehen, sondern man hat immer wieder so, man hat natürlich auch diese Momente, aber oft weiß man eigentlich, was zu tun ist und muss das halt nur eine Zeit lang machen.

Und beim Programmieren ist es oft so, also ja, man muss sich erst daran gewöhnen, sozusagen überwiegenden Teil der Zeit halt irgendwie mit dem Kopf vor der Wand zu stehen.

Aber das ist ja auch irgendwie so ein Rewarding, ja, weil du halt da stehst und du hast ein Rätsel und du knackst es dann irgendwann hoffentlich.

Ja, aber das kann auch ziemlich frustrierend sein.

Ich finde es aber dann als Abwechslung auch ziemlich entspannt, irgendwie, weiß ich nicht, irgendwas einzurichten oder irgendwie Doku zu schreiben oder so, weil du weißt, du kannst dann halt irgendwie die Zeit einzahlen und du machst das dann halt und hast du ein Ergebnis nach der Zeit.

Das ist halt schon auch nett.

Ja, so zur Abwechslung die Kommentare zu dem Code zu schreiben, ist auch schon ganz gut.

Aber ich verstehe, was du meinst, dass du quasi programmieren keinen Anteil an Fleißarbeit hast, sondern du bist halt immer bei den 80% machst du in 20% der Zeit und danach hängst du bei diesen 20% fest.

Du musst einfach wissen, wie es geht.

Und wenn man tatsächlich messen würde, wie viel Zeit man so beim Programm braucht, ich meine, der Großteil ist ja schnell runtergeschrieben, nur die Fehler, die brauchen dann viel mehr.

Und weil im Grunde weiß man ja auch, was die.

Man schreibt eine Zeile und weiß, in der nächsten Zeile muss das und das stehen und dann kommt die Vorschleife und dann packe ich da rein das und so weiter und so fort.

Wenn ihr so einen Fehler habt, wie geht ihr denn da ran?

Also versucht ihr den zu debuggen, indem ihr guckt, was, also warum das ist, oder versucht ihr den auszuprobieren, wie man den lösen kann.

Ich habe noch nie

wirklich einen Debugger verwendet, sondern immer nur Print.

Ja, ich auch nicht.

Also wenn

ich einen Syntax-Fehler habe, gut, dann sehe ich im Traceback, aha, zelle das und das, was sagt denn der Fehler?

Aha, okay.

Schwieriger ist es natürlich bei semantischen Fehlern, wo das Programm keinen Fehler wirft, sondern du mit der Ausgabe nicht zufrieden bist, da ist dann die Anwendung ja okay.

Ich packe da jetzt ganz viele Prints rein und gucke, da ist es noch richtig, da auch, da auch, da falsch.

Okay, ich finde, es muss ungefähr da sein.

Oh ja.

Und dann, okay, das ist jetzt ein Ausdruck, der drei ineinander verschachtelte Funktionsaufrufe, dann verschachtel ich die jetzt mal in drei Zeilen und dann jeweils Print vorher, Print nachher.

Und meistens mache ich es dann so plumm, also Debugger, ich.

Also wir es Code soll auch einen sehr guten Debugger an der Stelle haben für so Zeugs.

Dass man halt die Variablen testen kann, immer

genau da

und diesen Prints nicht dann immer einem, den man nicht extra in den Code schreiben muss, sondern irgendwie in den Debugger und so.

Ja, aber meistens nehme ich dafür dann auch einfach einen Print und einen guten Lösung.

Und wenn euch

nicht, also nicht einfällt, diese Lösung, guckt ihr dann in die Dokumentation oder werde

euch dann einfach

angezeigt und guckt ihr in

die Module rein oder sowas?

Meistens hilft es auch, wenn man ein Traceback hat, den einfach mal zu googeln.

Also es mag unglaublich doof klingen, aber wenn mir ein Fehler angezeigt wird, eventuell aus einem Modul, das ich importiert habe, den ich nicht kenne, der mir nichts sagt, dann kann ich den googeln und da wird garantiert schon, wer anders auf Stack of a flow dieselbe Frage gehabt gehabt haben.

Und da hilft es meistens auch, zumindest um schon mal zu verstehen, um was für einen Fehler es sich handelt.

Klar, bei den normalen Facebacks ist das relativ simpel.

Wenn da Zero Division Error steht, dann habe ich durch Null geteilt irgendwo.

Das kriegt man relativ gut gefixt, aber wenn man die Fehlermeldung nicht kennt, dann einfach mal googeln.

Aber auch vielleicht nochmal, was interessant wäre, was seht ihr denn, wenn ihr jetzt da viel Anfänger dabei beobachtet, das zu lernen?

Was fällt denen denn besonders schwer?

Ist das immer das gleiche oder sind es ganz, je nachdem, wer das ist, ganz unterschiedliche Sachen?

Bei Anfängern hat man teilweise noch tatsächlich Flüchtigkeitsfehler, so was weiß ich, Klammer nicht zugemacht, Gänsefüßchen offen gelassen.

Das sind natürlich ja gut.

Ist eventuell noch nicht gewohnt.

Klassischer Flüchtigkeitsfehler einfach vergessen, das kommt natürlich vor.

Dann gibt es Fehler, die quasi, wir schon wissen, dass sie auftauchen werden, weil ja recht zum Beispiel.

Jetzt werden Beispiele gut.

Wenn man zum Beispiel die falsche Variable benutzt, wenn du in der Vorschleife statt die Durchlaufvariable dein Interact.

Wenn du statt die Variable, die du als Durchlaufvariable hast, die Variable nimmst, die du durchläufst.

Das passiert schon mal, aber das ist dann ja auch eher ein semantischer Fehler, weil es wirft nicht zwingend einen Fehler, aber es tut halt nicht das, was es soll.

Und auch Leute, die eine Funktion nicht aufrufen, sondern nur die Funktion da hinschreiben.

Ja.

Vergessene Klammern beim Funktionsaufruf.

Ja.

Ich glaube, Anfänger machen jetzt nicht groß andere Fehler als fortgeschrittene.

Wenn du mehr weißt, kannst du auch mehr Fehler machen.

Ja, das stimmt.

Tatsächlich, ich glaube, Anfänger machen einfach nur mehr Flüchtigkeitsfehler.

Die sind das ja auch nicht so gewohnt.

Wie sieht ein String aus oder so?

Ich erkenne viele Fehler, ja, das ist tatsächlich auch optisch irgendwie.

Wenn mir der Editor anzeigt, guck mal, da geht ein String nicht zu, ja gut, dann mache ich den zu, aber wenn ich gerade damit anfange und jeder Buchstabe für mich quasi einen Einblick in eine neue Welt gibt, dann ist das eventuell schwieriger.

Also auch so, dass das Syntax-High-Lighting irgendwie in der falschen Farbe ist, das fällt mir ziemlich schnell auf.

Ja.

Weil man da auch ein gewisses, wenn ich Gefühl irgendwann hat man dann auch so einen Modus Operandi, zum Beispiel, wenn ich Gänsefüßchen nehme, dann macht mir der Editor automatisch zwei, wenn ich eins tippe, dann gehe ich einmal nach links, um in dem Gänsefüßchen zu sein und dann tippe ich da rein.

Und was weiß ich, ein Anfänger würde dann wahrscheinlich Gänsefüßchen, den Stringen und dann nochmal Gänsefüßchen und dann vergisst es dir den zweiten.

Oder der Textedur verfügt ja nochmal zwei ein.

Dann hast du drei und dann klappt das auf einmal zu.

Da lappe ich ja immer noch regelmäßig rein tatsächlich.

Ja.

Also ich würde behaupten, Anfänger machen dieselben Fehler.

Vielleicht nur häufiger.

Aber ich glaube gar nicht so häufiger.

Ja.

Gibt es denn auch Dinge, die Anfänger besonders toll finden?

Etwas, wo man irgendwie zuverlässig so einen WAU-Effekt mit erzielen kann oder was sie überrascht, wie einfach das geht?

Gerade so grafische

Sachen sind immer ziemlich überraschend.

Wir haben mal irgendwann Turtle gezeigt.

Und dass man einfach so schnell irgendwie.

Also gerade so grafische Ergebnisse, wie weiß ich nicht, Rechtecke oder sowas oder irgendwie Flächen überraschen Leute doch.

Ja, es ist natürlich immer gut, wenn man direkt was zeigen kann, was auch so ein bisschen über eine Kommandozeile, also klar ist es noch eine Kommandozeilenanwendung, aber wenn dann plötzlich ein Fenster aufgeht und da ist ein Bild drin.

Oder wenn ein Fenster aufgeht und auf einmal ist da ein Graph drin.

Was ich persönlich finde, finde bunten Text mit Terminal ja spannend, aber.

Ich finde das auch schon sehr spannend.

Irgendwie sehen das

andere Leute nicht so.

Ich weiß nicht mehr.

Die Leidenschaft hat nicht so ausgeprägt waren.

Wir haben, glaube ich, mal einen Abends dort ziemlich stark gelangweilt, indem wir sehr viel zu Terminals erzählt haben.

Ja, das.

Ich glaube, du warst dabei, ne?

Ich fand's gut.

Das hatten wir letzten Abend, da haben wir was mit Bildern gemacht.

Das hat natürlich den Vorteil, dass man direkt was Buntes sieht und auch die Erinnerung direkt sieht.

Ein bisschen für die Augen.

Ja.

Ein bisschen was für die Augen.

Voll die krassen Sachen gesehen, die man mit Blender machen kann.

Man kann halt diese ganzen interaktiven Grafiken generieren lassen mit, weiß ich nicht, 20 Zeilen oder so.

Aber dafür müssten wir eine Ahnung von Blender haben.

Tja.

Das sah auf jeden Fall

cool aus.

Ich habe mir das tatsächlich, als wir am letzten Donnerstag was mit Pillow und Bildern gemacht haben, habe ich mir das direkt als.

Hab ich

da richtig was verpasst?

Ja, habe ich das direkt als Anfang dafür genommen, mich ein bisschen mehr mit Pillow zu beschäftigen und habe da jetzt ein kleines Projekt, das ich mit Steganografie beschäftigt.

Oh.

Ja, gerade so zu den höheren Leveln fehlen uns doch so sinnvolle Beispiele.

Ja, das stimmt.

Aber da kommen wir gerade ja dazu.

Pillow, was sind eure Lieblingsmodule?

B-Python, ganz klar.

Ja, B-Python ist ja ein Interpret.

Aber ich stimme dir zu, B-Python ist schon ziemlich cool.

Boah, mein Lieblingsmodul.

Jetzt hat er B-Python gesagt, jetzt will ich nicht einfach auch B-Python sagen.

Kannst du ja C-Python sagen.

B-Python.

Ja, Requests finde ich ziemlich cool, weil man damit sehr einfach halt Netzwerk machen kann.

Gerade auch so, wenn Leute irgendwie, also es gab Leute, die hatten irgendwie so eine so eine Comic-Seite oder so und da wollten die irgendwie eine Benachrichtigung haben, wenn es Neuen gibt oder sowas.

Gerade so Projekte, die eigentlich einfach sind, aber dann doch irgendwie überraschend sind.

Gehen aber ziemlich schnell.

Ich glaube, ich HuayPy, das wäre schon.

Das finde ich cool, weil es bringt Farbe ins Terminal und besteht nur aus 56 Zeilen Code oder so.

Also das ist für mich ein schönes Beispiel, wie man sehr einfach ein.

Klar, das ist jetzt auch nicht so das große Werkzeug, aber es bringt doch ein großes Plus an Usability und dafür 56 Zeilen finde ich echt gut, vor allen Dingen der Großteil davon ist einfach nur ein Dictionary.

Dann, was ich noch gut finde, ist Parflip.

Oh ja.

Einfach, weil wenn ich sehe, wie man vorher mit OS.parts mit Dateien gearbeitet hat und wie viel einfacher das jetzt mit Parflip geht.

Aber das ist ja kein, also ich meine, das ist ja Teil.

Das ist Standardbibliothek.

Aber ja, ich meine,

auch da gibt es ja viel zu viele Dinge, die eigentlich cool sind, die zu wenig bekannt sind insofern.

Und das denke ich, ja.

Jochen, was ist deine Lieblingsmodul?

Mein Lieblingsmodul, oh je.

Ich weiß nicht.

Ich glaube, ein Lieblings-Hätte auch gar nicht wirklich drüber nachgedacht.

Also, was ich letztens gesehen habe, was ich ganz cool fand, was ich noch nicht kannte, war SQL-Paths.

Womit man, also SQL-Statements, die man ja, also wenn man jetzt zum Beispiel so ein ORM verwendet und dann fällt da so ein Statement bei raus, wo man guckt sich der dann manchmal an, weil irgendwie ein Statement ist langsam oder irgendwas, was man mit dem ORM macht, ist langsam und dann bei Django kann man halt einfach sagen, irgendwie man das Query-Set hat, Queryset.Query und dann spucht das Ding das SQL-Statement aus, allerdings dann halt so als langen String, was relativ unleserlich ist und mit SQL-Parts kann man halt einfach sagen, okay, formatier mir

das mal neu, indentiere das alles und dann sieht das halt nach einem hübsch formatierten SQL-Statement aus und dann sieht man halt auch, was passiert.

Und genau, dafür habe ich das letztens verwendet und fand das sehr praktisch, dass es sowas gibt.

Ja.

Tja.

Weiß nicht, was hättest du denn so an Python-Modulen oder so?

Irgendwie da habe ich jetzt doch gar nicht durch, aber ich fand Kiwi ganz witzig irgendwie.

Weil das auch direkt irgendwie so Touchbietet für so kleinen Unsinn und wenn man jetzt nicht total die aufwendigen GUIs bauen will, da relativ einfach ganz witzige Lösungen hinbekommen.

Ja, was mir da, ah, was mir noch einfällt, genau, ich weiß nicht, ob wir das schon mal hatten.

Pythonista ist ziemlich ziemlich cool.

Das ist so eine, das ist tatsächlich ein Python-Interpreter auf iOS.

Keine Ahnung, wie das Ding durch den App Store gekommen ist.

Das kann eigentlich nicht mit rechten Dingen zugegangen sein, irgendwie, aber das tatsächlich irgendwie vollständiges Python 3.6.

Und tatsächlich, wenn also jemand mit einem, gut, das kostet Geld, das kostet irgendwie ein paar Euro, aber das ist wirklich, wirklich ganz toll, hat auch eine schöne Idee dabei.

Also wenn man jetzt irgendwie ein iPhone hat oder ein iPad und eine Bluetooth-Tastatur, dann könnte man auch tatsächlich wahrscheinlich irgendwie Python 2 damit teilnehmen, was man jetzt gar nicht so erwarten würde, weil eigentlich ja iOS irgendwie auf Objective-C, C<unk> und C und was gibt es dann auch, Swift wie beschränkt ist.

Aber genau, und was halt auch sehr schön ist, ist, dass man da viel Zugriff hat auf die APIs.

Also man kann halt, also man kann auf die Fotos zugreifen, Location-API, man kann grafische Geschichten machen und das Ding nutzt halt auch die nativen Widgets von iOS, sodass das halt auch alles, also jedenfalls von den Animationen her und so schnell ist.

Und ich habe es halt mal benutzt, um so ein Sharing-Dings, so ein Dings in ein Share-Sheet reinzubauen, sodass man dann, wenn man im Browser sagt, URL teilen, dass ich das halt dann in meinen Bookmark-Service irgendwie reinpipen kann.

Genau.

Und dann die ganze Bearbeitung, also das sprechende Rest-API oder so, das macht dann halt alles irgendwie Pythonista oder ein Skript, das halt dann von Pythonista ausgeführt wird.

Ja, das ist auch ziemlich cool.

Wenn man das nicht kennt und iOS irgendwie Python machen möchte, dann ist es, glaube ich, ganz hilfreich.

Ja, sowas ähnliches gibt es auch für Android Thermox.

Das Terminal.

Ja, genau, es ist ein Terminal-Emulator.

Sogar mit Paketmanagem allem drum und dran.

Genau, also es bietet halt sehr viele Möglichkeiten, auch mit Android selber zu interagieren.

Also irgendwie, weiß ich nicht, Kontakte, SMS zu senden oder sowas.

Und es läuft halt auch Balken drauf.

Also es kommt halt mit einem Paketrepo von sehr vieler Software.

Und es ist halt eigentlich alles so an Sprachen dabei, die man haben wollen würde.

Also wie ein C-Compiler, Go-Compiler, Rust-Compiler, was nicht so wirklich gut läuft, ist leider Java, was bei Android ein bisschen komisch ist eigentlich.

Aber ansonsten, ja, unter anderem auch Python.

Also was ich auch noch natürlich cool finde, ist das GPIO.

Also auch dem Raspi oder sowas ist es natürlich ganz super gut.

Es blinkt es immer gut, ne?

Genau, ganz viele coole, einfache Sachen machen kann, die man auch super schön zeigen kann.

Also einfach jetzt ein paar Pinne ansteuern und so ein Lämmchen zum Leuchten bringen, das kriegt auch jedes Kind hin und man hat halt direkt was, was man sehen kann.

Das ist irgendwie immer schön.

Generell kann man auch sagen, dass die Python Standard Library sehr viele, sehr coole Module enthält.

Das finde ich extrem cool, weil ich mich immer dafür interessiere, wie funktioniert sowas eigentlich?

Und mit DIS kann ich mir halt den Python-Byte-Code für eine Funktion anzeigen lassen.

Und es ist halt nicht nur einfach die Byte, sondern es hat doch wirklich die Namen der Instruktionen und die Parameter daneben und so.

Und das ist schon ziemlich cool.

Also generell ist die Standard Library ja so umfangreich, dass wir bei den Anfängern größtenteils nur die Standard Library benutzen müssen.

Das sind halt auch so Sachen dabei, wo man sich denkt, warum ist das jetzt eigentlich in der Standard Library?

Und andere Sachen nicht.

Ja, das ist manchmal ein bisschen komisch.

Wie zum Beispiel IMG HDR, das kann dir von einer Bilddatei sagen, welches Dateiformat das ist.

Quasi so ein Pfeil-ähnliches Dings muss in der beiden Standard Library eingebaut.

Und da habe ich mir gedacht, warum?

Aber naja, das ist ganz praktisch manchmal.

Ja, ja.

Oder Wave ist es auch als Codec da drin.

Ja, und da gibt es andere Bereiche, in denen gibt es dann irgendwie drei Module, die irgendwie das gleiche, nur auf unterschiedliche Art tun.

Urlaub, Urlaub 2, Urlaub 3.

Einfach und

Requests gibt es nicht in der Standardbibliothek und so.

Und das ist schon so ein bisschen.

Ne, also Requests ist auch so das eine der Dinge, wo ich mir wünschen würde, dass es eine Standardlage wäre.

Schreibt uns auf jeden

Fall eure Lieblingsmodule.

Ja, wobei, also bei was mich an Requests halt noch so ein bisschen, also ich meine, das ist von der Benutzung her, ich meine, das ist ja auch der Anspruch, irgendwie, ist halt HTTP für Humans, ne, irgendwie, wenn man das jetzt als Anwender, sonst als Entwickler-Anwender benutzt, ist es halt sehr praktisch.

Aber wenn man jetzt zum Beispiel viele HTTP-Requests machen möchte oder so, dann ist es halt auch schon nicht mehr so toll, weil man, das ist halt nicht asynchron.

Also man halt Multiplex halt sozusagen I.O.

nicht, wirklich.

Kann das dann eventuell machen, indem man halt Sweats verwendet oder so, aber so von sich aus kann das das halt nicht.

Und dann gibt es halt vielleicht auch, wenn man das halt noch nicht kennt, ähm AIO HTTP, äh, HTTP ist, glaube ich, die Bibliothek oder das Projekt, ich weiß nicht so genau.

Und da gibt es einmal einen Server.

AIO HTTP.

AIO HTTP.

Und da gibt es einen Server drin und es gibt halt auch einen Client und der ist basiert halt auf Async.io und das ist halt richtig schnell und da kann man halt auch mal gibt es auch ein schönes Beispiel, das hat's einen Artikel von ich habe jetzt den einen Namen vergessen, aber Guido von Rassum ist der andere Autor und die beschreiben halt so, wie kann man mal so eine Million Webseiten, äh, Millionen Requests machen, irgendwie schnell.

Und das, äh, ja, sehr nettes Ding.

Jo.

Ja.

Also ich würde sagen, wir haben viel gehört dazu, was wir, ja, wie man anfangen kann, wie man vielleicht weitermachen kann, welche Probleme so am Anfang auftauchen, wie man die so ein bisschen umschifft.

Also wenn ihr ein Distel auf den Umgebung seid, dann kommt ihr einfach vorbei, ne?

Genau.

Ja, einfach so, ich glaube nicht nur donnerstags sind da ein paar Jungs immer da.

Ja.

Das sage ich halt jede Woche.

Also nicht unbedingt mit uns, aber ja.

Da gibt es auch andere coole Menschen.

Ja.

Ja, wenn ihr irgendwas antragen wollt, nochmal Events, wieder euer Feedback, Kommentare an hallo.python-podcast.de.

Ja, schön, dass ihr wieder eingeschaltet habt.

Genau, und dann versuchen wir mal irgendwie die nächste Sendung etwas zeitnah hinzukriegen.

Ja, wir hatten eigentlich schon etwas vorbereitet, aber das hat nicht so gut geklappt.

Da müssen wir nochmal dran.

Datenbanken, wir können ja schon mal erstmal verraten.

Haben wir uns irgendwie auf die Fahne da geschrieben.

Wer hat eigentlich Model View Controller erfunden?

Hugh Hefner.

Okay.

Bis zum nächsten Mal.

Alles klar.

Tschüss.

Tschüss.