Transcript: 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 meinem Equipment geupgradet und mal gucken, wie das jetzt so wird.

Wir haben jetzt zwei Headset-Richtige und auch so ein bisschen mehr Mischpult ist jetzt heute als sonst, weil wir uns dann zu diesem Thema zwei Leute noch mit dazugeholt haben, die vielleicht da was...

Ich habe mich jetzt nicht zu sehr dodo, also ich habe auch nicht mitgebracht.

Hallo.

Hallo.

Die dort die Einsteiger-Veranstaltung für Python halt jetzt schon seit einiger Zeit betreuen und dann, genau.

Die sehr gute Einführungsmacht.

Ja.

Oh.

Nicht zu viel Glauben.

Ja.

Ja, und genau, mal schauen, wie es so wird damit.

Ja, Fragen, Anmerkungen, Kommentare und alles, was ja so loswerden müsste,

bitte immer gerne in unsere E-Mail schreiben,

hallo.peisen-podcast.de.

Dabei auch direkt vielen Dank.

Wir hatten Kommentare, schöne, bei der letzten Folge.

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

Genau, und das war sehr positiv.

und das ist natürlich mal 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

den Kram zu maintainen, können wir

halt nicht irgendwie zum

Aufnehmen von Podcasts

verwenden, aber ja, also

Genau, falls unser AXE 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 dann 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 und ja.

Ja, das kannst du vielleicht gleich nochmal bei der Modulvorstellung von deinem

neuesten DjangoCast-Fortschritt

erwähnen. Was die Leute

sich auch gewünscht hatten, also unsere Hörer, war Struktur.

Frechheit.

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.

Genau, aber

vielleicht machen wir einfach erstmal eine Vorstellungsrunde.

Ich meine, wir beide

sind jetzt schon irgendwie bekannt, aber 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 Niklas das

Python-Foo-Light im Chaosdorf.

Das ist das

Python-Foo für Anfänger

in Python oder Anfänger in

Programmierung im Allgemeinen.

Das ist jeweils der 1. und 2. Donnerstag im Monat.

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

Und das machen wir jetzt seit 3 Jahren.

2015, oder?

Ja, ich glaube, mittlerweile 3 Jahre.

Irgendwann im Sommer, ja.

Da kann man übrigens immer gerne vorbeikommen.

Natürlich.

Ich bin ja Niklas, hallo.

Wir haben das damals angefangen, ich glaube, irgendwie ein halbes Jahr,

nachdem es den Gamedev gab.

Es gibt da gewisse personelle Überschneidungen mit Leuten,

die dann halt nicht mehr die Zeit hatten,

auch noch den Python-Fool 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-Fool 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ödesten 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,

sind wir 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,

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

sich jetzt nicht irgendwie da

bewusst für entscheidet, irgendwie diese, den

News da zu konsumieren, was dann da irgendwie hängenbleibt.

Also ich lese ab und zu die

Release-Notes zu neuen Python-Versionen,

aber es gab 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.

Ja, 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

wieder, 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 mein

RSS-Reader seit irgendwie drei Jahren

nicht mehr aufgemacht.

Eine 10.000 Nachrichten.

Das letzte neue Feature von Python, das ich

verwendet habe, war NameTouples, glaube ich.

Das fand ich ganz cool,

so als einfacher Klassenersatz.

Es gibt noch einen coolen Newsletter für Python.

Oh, Newsletter.

Ja, da stellen wir auch die

Shownotes dann vielleicht mal rein.

Wir sollten die Newsletter vielleicht mal reinpacken.

Also es gibt ein paar. Ich habe irgendwie einen Awesome Python,

einen Python Weekly.

Ich habe auf GitHub die Trending

Repos abonniert. Das gibt es für

familiäre Sprachen und unter anderem auch für Python.

Oh, das ist ja super.

Das ist halt

teilweise Sachen, die halt irgendwie nur

zufällig in Python sind und nicht wirklich

dafür relevant sind, aber

manchmal ist auch was Spannendes dabei.

Ja, 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

habe ich irgendwie Aggregator verwendet

unter 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 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 und das 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 Planet Python und da gibt es noch so ein paar

Blogs von Leuten,

die halt da an Python

rum, äh, an, äh, an Python

halt an Junkroom entwickeln, halt auch abonniert.

Ja.

Tja, ähm,

äh, genau, ja, das, das mit dem,

mit den Dataclasses ist Python 3.7

oder es gibt ja jetzt, vorletzte Woche, glaube ich,

3.8 nochmal ein paar Ankündigungen, genau.

Genau, da gab's eine neue Alpha-Version und zwar

gab, gibt's da auch eine Syntax-Änderung,

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

Ähm, war das das mit dem Doppelpunkt

gleich, dass man in, ach ja,

das war doch, dass man in, wie war

das, in Schleif, äh, in

der Deklaration von einer

Wildschleife kann ich mir die

Variable setzen, oder?

Das war eine Zuweisung, die dann auch

wieder direkt den Wert hat. Genau, also man

macht eine Zuweisung und gleichzeitig hat die

entweder true oder false.

Es gab da auch irgendwie einen witzigen Namen

für den Operator, ne? Ja, da komme ich

nochmal. Irgendwie nach dem Tier, ne?

Walrus-Operator, weil

das ein bisschen aussieht wie ein

Augen und Zähne, ja.

Das ist so ein bisschen wie dieser Turbo-Fisch,

wenn du hast, ne? Turbo-Fisch.

Das hatte ich auf Twitter, glaube ich,

mitbekommen. Das hatte mir

irgendwer retweetet. Das fand ich auch sehr

interessant.

Ja, und genau, man kann sich damit halt

umgucken. Also man halt macht halt oft so was

wie man holt irgendwas, einen Wert

aus einem Dikt und dann muss man

erstmal überprüfen, ob das nicht None ist, weil

man weiß halt nicht, ob es...

Die Zeile kann man sich jetzt immer sparen und man schreibt dann halt

direkt, if irgendwie

dann irgendwas

Valros Operator

Verdikt.getKey,

dann macht man halt weiter, wenn es

drin war und ansonsten...

Ansonsten wäre für sowas ja auch so ein SafeNavigation

Operator nett. Es gibt ja Sprachen,

da kannst du irgendwie Fragezeichen Punkt machen

und die machen dann in den Zugriff nur, wenn das Objekt selber

nicht null ist. Ein SafeNavigator,

das musst du bitte kurz erläutern.

Also es ist ja auch praktisch so, dass du irgendwie ein Objekt hast

und es hat ein Attribut. Dann machst du irgendwie

Objekt.Attribut. Irgendwas.

Und eigentlich musst du ja bei jedem

dieser Schritte prüfen, ob das Attribut

selber nicht null ist.

kannst du ja nicht Punkt machen. Es gibt halt

Sprachen, die haben so ein Syntax-

Fragezeichenpunkt, die macht

halt den Zugriff nur, wenn das Objekt selber nicht None ist

und ansonsten ist der Wert halt auch direkt

wieder None. Das fände ich cool,

kenne ich über Python nicht. Ja, und da hatten wir

tatsächlich, ich weiß nicht, kennt ihr das? Es gibt

ein Telegram-Channel

zur Python-User-Group

Düsseldorf, PyDDF. Nee, kenne ich nicht.

Ah, ja.

Die User-Group, die kenne ich,

da war ich ein paar Mal, aber den Telegram-Channel

sagt mir nichts. Genau,

Es gibt immer noch eine Mailing-Liste,

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 Chezy, den wir als Expertengast

für unsere 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

vorgestellt und meinte so, das wäre doch eine tolle Idee.

Und dann hat sich das aber relativ

das war sehr kontrovers,

das war ein sehr polarisierender

Also ich habe es auch noch nie genutzt, ich weiß nur, dass es existiert

in anderen Sprachen.

Ich bin mal gespannt, kann ja sein, dass es auch in Python irgendwann kommt.

Genau.

Ja, es gibt noch mehr Neuigkeiten

von dem Steering-Counter.

Da wolltest du vielleicht noch was zu sagen.

Genau, ich habe da jetzt

auch nicht so einen Detail

verfolgt, aber es ist halt so, dass

Guido ja sozusagen

so einen unbegrenzten

Urlaub genommen hat von seiner

BFDL-Rolle

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, jemand irgendwie das letzte Wort haben muss, dann gibt es halt diesen Rat, der das dann 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 sind alles nette Leute

insofern. Ja, sieht gut aus.

Und jetzt kommt noch eine nächste Neuerung, und zwar gibt es jetzt

lokale Packages in Python.

Ne, das gibt es auch erst

mit Python 3.8. Genau.

Stimmt, das war auch in der Alpha-Release

drin. Python Local,

ja, pip local

gibt es so ein Verzeichnis dann.

Ui, jetzt muss ich mich wieder versuchen, daran zu erinnern,

was das eigentlich genau ist.

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 drumherum 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 ein Target angeben

und das ist dann, ah, okay.

Und das ist dann, glaube ich, einfach

das heißt dann einfach PIP-Local

und dann installiert es halt in das Verzeichnis rein

und dann... Dann hast du alles in einem Ordner.

Das ist cool.

Auch gar nicht so schlecht.

Also ich weiß nicht, ob es jetzt Virtual Env

komplett ersetzen wird, aber

auf jeden Fall. Also ich meine, gut, wir haben ja jetzt

drei oder vier unterschiedliche Arten, wie man das machen kann.

Viertel wird bestimmt das Problem lösen.

Und die beste ist natürlich PIP-Env.

Ja, PIP-Env ist auch toll.

Das stimmt, das ist schon gut.

Genau, zu sowas.

Isolierung,

Isolation, Virtual Envs, 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...

Ja, eine extra Folge, okay.

Ja, dann fangen wir doch jetzt am besten

mit unserem Thema an, oder?

Ja, klar.

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 dem Texteditor arbeite.

Wenn ich schon mal eine IDE bedient habe,

weiß ich, was eine IDE ist. Oder Schleifen.

Genau.

Das geht natürlich weiter

mit den Kommandostrukturen.

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 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 Namespaces oder dynamische Topisierung vielleicht eventuell sogar einfacher zu lernen,

wenn man das 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.

Ja, ich hab so die

Aufmerksamkeit auf Hackathons oder so, wo ich

dann irgendwie

Leute hatte, die dann halt

aus sehr unterschiedlichen Bereichen kamen, aus sehr unterschiedlichem

Wissensstand hatten und dann hat man versucht,

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 Virtual Env erzeugen,

dann irgendwie die Abhängigkeiten installieren.

Und dann sind zwei Tage rum. Genau, und das

ist teilweise, weil was mir dann immer

passiert, oder die schlimmsten Fälle sind immer 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.

Andererseits, wir verwenden zumindest am Anfang nichts,

was irgendwie extra Module braucht.

Also man braucht einfach nur einen Python-Interpreter.

Und viele Systeme,

irgendwie OSX 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 Programme installiert.

Weiß ich nicht.

Bei den meisten Leuten, die ins Chaos aufkommen, hat das dann

vielleicht auch funktioniert? Ansonsten kann man sowas

ja im Notfall auch irgendwie online machen.

Es gibt ja irgendwie Python Anywhere oder sowas.

Das geht ja irgendwie.

Außerdem haben wir, glaube ich,

in Wiki die Ansage stehen, dass man,

wenn man zum Python-Fuhr kommt,

einen Rechner mitbringt und

auf diesem Rechner...

Ja, okay.

Sonst können wir vielleicht ein Recipe 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.

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 installier 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 passenden Interpreter

brauchen. Wir hatten witzigerweise

noch niemanden, der dann irgendwie mit React

oder BSD oder sowas aufgetaucht ist.

Ich glaube,

das brauchen wir auch nicht.

Ja, okay, aber

Das ist ja schon mal interessant.

Ihr verwendet doch einfach die ganz normale

Python

Python-Reppel oder was kann ich mir

das...

Wir zeigen die Beispiele meistens entweder im Texteditor

oder irgendwie in I-Python, B-Python.

Aber das braucht man 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 Old 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.

Stimmt, ja. Und

HuPy. Stimmt.

Ja, aber das ist eine Datei

mit 56 Teilen, also ich glaube,

die muss man nicht installieren, die kann man notfalls runterladen.

Genau. Die könnte man wahrscheinlich

sogar abtippen.

Was war das nochmal genau? Ich habe das, glaube ich, gerade nicht so richtig verstanden.

HuPy. Kenne ich gar nicht.

Es ist ganz schön, um einfache

Statusmeldungen auszugeben. Das macht dann halt irgendwie,

es gibt HuPy.info und dann bekommst

so einen blauen Kasten, links so eine Welle

und dann rechts ein Text.

Farben im Terminal.

Es funktioniert auf allen Systemen.

Also Windows ist nur neuer als 10, aber

ansonsten...

Und es ist halt eine wirklich kleine Datei.

Wer fängt denn mal die Texte an?

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...

Das Readme ist sehr gut.

Ja, das Readme ist sehr gut, weil der Entwickler da vergleicht,

wie schwierig es ist, mit anderen Bibliotheken Farbe ins Terminal zu bringen

und wie einfach das mit UPy ist.

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 Python Hui.

U-Pi und Python Hui sind zwei verschiedene Dinge,

wichtig zu wissen.

Wir inszenieren immer die falschen am Anfang, ne?

Wie habt ihr beide denn

Python gelernt?

Ich weiß es ehrlich gesagt nicht mehr. Ich glaube,

ich habe früher mit einem

Freund zusammen

PHP angefangen, irgendwann an der Grundschule

und dann fanden wir irgendwann PHP nicht mehr

cool und dann ist er

zu Perl gewechselt und ich fand

Perl auch nicht cool. Dann habe ich mir angeguckt, was gibt es noch

zum Ansprachen? Dann habe ich mit Python angefangen.

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

Ja, genau.

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.

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 habt.

Ich hatte da mal...

Naja, alles gut.

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

Der Tee war lecker.

Danke, Tja.

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

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 oder? Ja, ich glaube wir hatten da eine

Free Pascal,

das war so ein bisschen wie die Python Idol,

nur ich fand es halt

sau anstrengend

mit Turbo Pascal zu programmieren

und irgendwann war die neunte Klasse

dann fertig und ich glaube, so zu

den Sommerferien fing ja im Chaosdorf

das Python-Fu an, weil das

Chaosdorf bekam halt neue Räume.

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

Ja, ja. Oh. Und

da fing das Python-Fu dann auch

komplett im Renovierungsmodus

mit... Umzug auf

Python 3. Genau.

Man könnte sagen, es lag

am Umzug auf Python 3, aber nein, da

Wurde gerade als Chaosdorf 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 gekommen.

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 Python-Fu gekommen bin.

ja, später habe ich dann

wieder eingesetzt und ja, seitdem beschäftige

ich mich damit hobbymäßig.

Und das

voran. Naja, weil

ihr Geld bekommt man dafür nicht.

Ja.

Naja, 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 einer davon sitzt ja hier.

Ach ja.

Du darfst jetzt überlegen, wer.

Wir sind meistens da.

Ja, ich glaube, ein paar

Leute sind tatsächlich

zum Python

hinzugekommen,

aber meistens hatten die schon ein bisschen

Background Python-Technik.

Es gibt halt Leute, die kommen einmal,

es gibt Leute, 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.

Da kommen 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

Diktion Leuten geteilt?

Die erste können wir am besten, weil wir es

am häufigsten getan haben. Also das ist

natürlich bei uns auch ein

progressierender

Progress sagen. Hat uns da mal eine sehr schöne

E-Mail geschrieben, warum wir alles zu schnell

machen. Auf die wir auch nicht geantwortet haben,

weil wir sind super. Ich fand aber jetzt 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-Report

und da kann man sehen, was wir bei ihm geändert haben.

In dem Repo, könnt ihr einmal kurz die Adresse

nochmal... Wir diktieren es hier nicht.

Nee, könnt ihr die nicht einfach in die Show Notes packen?

Ja, ja, doch, doch, genau, die packen wir in die Show Notes.

Python for Light. Ihr findet das Repo in den

Show Notes.

Ja. Ich glaube,

das ist auch schon in der ersten

Folge, oder? Aber das ist ja schon,

wenn man das ein paar Mal gemacht hat,

das wird ja dann immer polierter. Habt ihr mal drüber nachgedacht,

das irgendwie, keine Ahnung, irgendwie davon

einen Screencast zu machen oder das irgendwie mal

mitzustellen und zu veröffentlichen oder so?

Wir sind ja nicht Geld getrieben.

Ja, wir sind nicht Geld getrieben.

Nee, darum geht's ja gar nicht.

Aber allein einfach, weil so viele Leute,

die das so oft gemacht haben, gibt's ja wahrscheinlich

gar nicht, ne, die in so einer Einführungsveranstaltung

irgendwie tatsächlich sind.

Wir haben uns halt überlegt, dass wir das Gitterprepo

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, stimmt.

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

Der Vorteil ist halt, wenn wir dann mal Abend haben,

wo niemand kommt, können wir an den Beispielen

arbeiten, was 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. Was mir jetzt auffällt, ist, 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.

Da hatte 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, wenn die Leute

halt sich nicht trauen, oder so, Fragen zu stellen,

dass man dann einfach als derjenige,

der irgendwie eine Schulung macht oder

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 nein. Das ist ein bisschen

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

Ich meine, das Gute ist ja, dass wir

ja meistens zu zweit uns dann auch selber

an den Ball so ein bisschen zuspielen können.

Unsere Überleitungen sind immer grandios.

Oh ja.

Sind berühmt.

Ich glaube, so positiv.

Ja, ich glaube,

Wir haben da durchaus noch

Verbesserungspotenzial, gerade was

den Beispielcode angeht.

Ulrich West hat gerne gesehen.

Gerne, genau.

Ja,

ich glaube aber,

dass wir das schon relativ gut hinkriegen.

Bis zu welchem Level geht

denn der Python-Fool 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 10 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, bis wohin haben wir gemacht,

sondern in keinem 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. Das ist ganz einfach. Zahlen

müssen die Äquivalenzklassen

gleichmächtiger Mengen.

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 der

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.

Das ist ja auch eine Stärke von Python, 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 Shizi 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 mal 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. Ja.

Und irgendwie so

eine Whisky-Sache

mit Werkzeug.

Die haben wir noch niemandem gezeigt,

weil Leute sind nicht lange noch gekommen.

Die kennst du ja auch noch nicht, die Whisky mit Nergst und Gold.

Ja, musst du mal wieder kommen.

Ist geplant.

Ich wundere übrigens auch, wie du die Markdown-Seite im Kopf ausländisch kannst.

Naja, es sind jetzt drei Jahre, das hat sich nicht so groß an die Erinnerungszeit geändert.

Aber du hast die Witze entfernt.

Es gibt 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 Wikihistory

findet. Ich glaube, das reicht jetzt.

Also, war's okay.

Ja, es 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? Ja, ein bisschen.

Wir 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 man, 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 über Python weiß, tatsächlich

gelernt, dass ich es an den Leuten beibringe.

Wenn man dann immer noch so Sachen

merkt,

sieht man, oh, das weiß ich doch eigentlich gar nicht

so wirklich, wie das im 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.

Du wirst dann halt das Problem haben, dass wir vielleicht dann auch ein bisschen zu tief einsteigen, dass den Leuten, die da sitzen, dann doch nicht so wichtig ist.

Ja, das stimmt.

Ja, weil 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, 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 kleinen Kindern beibringen und die haben sich sehr darüber gefreut.

Und haben tatsächlich dann auch ihre ersten Programme schreiben können.

Das ist echt super.

Dadurch sind halt die Basics dann irgendwann wirklich

feste. Das ist vielleicht 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,

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 soweit korrekt.

Ja, Pseudocode, den man

ausführen kann, passt schon sehr gut.

Womit

fangt ihr denn an, wenn

ihr Leuten jetzt quasi

sozusagen das

Python nahe bringen wollt?

Was wäre denn sozusagen euer erstes Beispiel

oder sowas? Hello World natürlich.

Hello World, natürlich, genau. Das ist natürlich viel einfacher.

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

Danke an Plant. Danke an Plant für den Fernseher.

Ja, wir sitzen dann da am langen Tischreihe und einer sitzt meistens nah am Fernseher und zeigt dann auf B-Python 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 Jupyter-Notebook machen, das wäre vielleicht sogar noch ein Schritt weiter.

Ich benutze manchmal in den höheren Leveln Hydrogen, das ist ein Atomplugin, das so wie Jupyter funktioniert, zahlenweise.

Aber 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

Historie im Texteditor bearbeiten kannst

und dann wieder ausführen kannst.

Dann musst du es halt eigentlich nicht unbedingt speichern.

Und

B-Python kommt uns natürlich da

sehr entgegen. So mit Autovervollständigung

und Syntax-Verleitung, das ist schon echt cool.

Also, ja.

Es ist bunt.

Das B für bunt?

Ja, ja, das steht für Bunt-Python.

Weil

das ist auch deutsche Sprache.

Ja, und meistens in, ich glaube, spät höheren Leveln zeigen wir dann auch einfach die Code-Beispiele, 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 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 das wieder committen muss.

und so. 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.

Ja. Da wird es dann anstrengend

irgendwie mit B-Python. Das könnte man tatsächlich

wahrscheinlich eben

Jupyter-No-Pub machen.

Ja.

Aber dann hat man halt tatsächlich auch wieder

erstmal so einen Webbrowser dazwischen und dann muss man,

wenn die Leute das machen,

Wenn die Leute das nachvollziehen wollen,

wird es wieder schwerer.

Jupiter 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 dem Datensatz

in diesen Graphen sehen kann. Aber ansonsten

fand ich es eher so ein bisschen anstrengend.

Aber vielleicht bin ich jetzt auch nicht wirklich drüber

gestolpert.

Ich glaube, man hatte erst so richtig

den, also 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 den Fehler

korrigieren kann und das dann nochmal die Zelle

ausführt und es dann einfach weitergeht.

Das war dann so, wo ich mir dachte, wow.

Das ist der beste Debuggen dann quasi.

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 viel

Jobs habe, die eine Menge Zeugs

berechnen.

Ja, aber

nee, das ist schon, ja.

Jetzt sind wir gerade wieder bei der

Umgebung. Welche nutzt ihr denn so privat

dann?

Inwiefern Umgebung?

Benutzt ihr überhaupt eine oder bleibt da alles in der

Shell oder?

Ich schreibe meinen Code PeterNadel auf der Platte.

Ach so.

Also ich persönlich

ich 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. In 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.

Ja, ich glaube, ich habe jetzt einmal alles

ausprobiert.

Am Anfang war es tatsächlich

G-Edit, der

vorinstallierte Texteditor von Gnome.

Das hat auch gut funktioniert,

weil es hat halt Syntax-Highlighting

und mehr brauchte ich da nicht.

Dann war so ein bisschen meine Sublime-Textzeit.

Das hat jetzt auch nur ein bisschen mehr gemacht als G-Edit.

Also ich konnte 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-Kondole.

Mittlerweile bin ich bei VS Code

angelangt mit

ich glaube, ich weiß nicht, ob es da Plugins oder

Add-ons heißt. Jedenfalls

ein Flake 8 Add-on, dass

er mir direkt die

Type Annotations

Oh ja, MyPile. Ja, ich glaube,

das ist, ich habe glaube ich nur

das Flake 8

oder auch MyPile. Das ist großartig, habe ich auch

für mich entdeckt und da kann man ja auch die Kitverwaltung

direkt eintrauen und man hat so eine tolle

Live-Share-Funktion, da kann man kollaborativ

direkt arbeiten, als hättest du mal vor dem gleichen

Rechner.

Also aktuell

mein Workflow ist... Das gibt man im VI auch.

Screen minus X

und...

Das ist schon so ein bisschen angestaubt.

Letztendlich sind wahrscheinlich alle Texteditoren

irgendwie, aber wir scheinen alle nicht

wirklich so eine Idee zu nutzen, sondern eher

Texteditoren mit irgendwie zig Plugins, ne?

Ja, ich... Also PyCharm habe ich

installiert, ich starte es irgendwie jedes halbe Jahr

machen und machst 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,

es kann 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,

Selbst Atom, das ja

im Grunde auch mehr so ein

Browser mit irgendwie

JavaScript und dann im Editor in JavaScript

in dem Browser ist, fühlt sich halt viel

irgendwie

so agiler an als PyCharm.

Was man da sagen muss, ist, dass die bei Atom

in den letzten zwei Jahren wirklich stark an der

Performance gearbeitet haben. Also wahrscheinlich auch dadurch

bedingt, dass viele Leute auf VSCode umgestiegen

sind, weil es halt schneller war.

Atom ist wesentlich schneller geworden tatsächlich.

Ah, okay. Muss ich vielleicht auch nochmal ausprobieren.

Ich finde, der Niklas hat auch eben

einen guten Punkt gebracht, dass eben

klar, wenn ich mit Python arbeite,

gibt es wahrscheinlich nichts Besseres als PyCharm,

also keine umfassendere

Lösung, gerade weil

die Professional-Version

auch noch sehr gute

Interaktionen

mit anderen Sachen, zum Beispiel Git oder

Django liefert, nur

gerade wenn ich

in mein 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,

dann 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

meine Tabellenkalkulation.

Also so am krassesten

habe ich mich gefühlt tatsächlich, als ich mit

Plattwurm irgendwie so ein Diagramm gemacht habe

und das dann halt in Atom auch

direkt schreiben und dann live gerendert habe und das

dann in Readme eingebunden und

das war schon recht

cool. Gerade für so Sachen, wo man

eben nicht nur Codedateien

im Repo

hat, ist glaube ich so ein Texteditor

mit Atoms

ist die bessere

Option, weil dann kann ich mir

VS-Code und dann habe ich eben

Autocompletion

für Python und mein

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ürde

ist auch geringer. Ich kann mir irgendwie

Subclime installieren, die Datei öffnen und da kann ich direkt

anfangen zu programmieren. Ich muss mir

nicht erst mal durch den Einstellungsdialog

klicken, um herauszufinden, wie ich jetzt zoome oder so.

Das funktioniert halt alles so,

wie man es erwarten würde. Das finde ich schon praktisch.

Das hatte ich,

VS-Code habe ich jetzt erst seit neuerdings,

also vielleicht drei

Monate.

Und da habe ich 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, das dir die Autocompletion

macht. Und ich so, ja, gerne.

Hier, wähle dein Linter aus.

Ja, gerne.

Grace yourself, Linter is coming.

Das ist ja sehr user-centric, ne?

Natürlich. Und

ja, in meinem

RSS-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 einzige große

Problem, was ich mal mit Atom hatte, ist

Atom konnte sehr spät

so Type Indications. Das hat bis

irgendwie 1.25 oder so

in feierlicher 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, war 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

Codes schreibe. Ja, aber so Type Annotations machen wir

uns am Anfang auch nicht sicher, wie wir das jetzt

tatsächlich, sollen wir das zeigen?

Soll das nicht zeigen? Ja.

Wir haben es 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 mit 3.4.

Mit allen.

3.1.

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

mit 3.2 oder 3.3 aufgetaucht ist.

Das ist einfach zu schwer zu installieren,

das schafft sowieso kein Anfänger.

Gibt es wirklich noch zwei Sachen irgendwo?

Docker, Python, Doppelpunkt, 3.2.

Ja, also ich

habe durchaus schon noch

zum Beispiel, was mich irgendwie auch

genervt hat beim Roster eines Kunden,

der hatte, dessen aktuellste Version war

Python 3.3, was halt

und das war auch bei Debian halt

irgendwie eine Zeit lang irgendwie so das, was halt

dann dabei war und

ja, das ist halt schon schlimm.

Weil so 3.4 wäre echt gut gewesen.

Ja.

Also wir sagen uns halt, wenn die

Version im Moment noch supported ist, dann

versuchen wir auch die zu verwenden.

Und es ist ja nur 3.4 im Moment noch

als älteste.

Also für mich war so 3.4

die erste richtig gute 3er-Version,

die man

ja, woanders nicht mehr so dauernd

Sachen auf dem Fuß gepreist hat.

Waren da letztes Mal 2 ü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,

so lange ist das jetzt auch nicht her,

2014, 15

gewesen.

Letzte Woche hat er sich ein Startup getroffen, die so einen Sensor

betrieben haben auf Python 2

API-Base.

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.

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?

Soll es ja eigentlich gar nicht geben, wenn ich die Leute

nicht verstanden habe. Ich habe einen Blogpost

von 2015 gefunden, wo

2020 drin stand.

Aber da ist dann Python 3 42 oder so.

Ich glaube es auch nicht.

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 Leasenodes 2.3.7 oder so

gibt es irgendein Feature, dass

Type Annotations als String betrachtet

werden, wo steht, dass

das Moment Opt-in ist, irgendwie mit From-Future-Import,

aber Python 4 macht das dann als Standard.

Und dann habe ich mir gedacht...

Okay.

Das mit dem Annähern an so eine

Zahl, das ist ja, das ist leider

schon ein bisschen vergeblich. Ich glaube, Latex macht E

und Tech macht Pi oder so, ne?

Oder? Die nähern sich mit ihren

Versionen schon irgendwie.

Wenn sie bei Sempfer bleiben würden, wäre ich

davor. Ja, das wäre auch ganz gut.

Das ist ein bisschen, also, ja.

Ja, wenn man,

wenn die Versionen nichts bedeuten, ist das auch

ein bisschen schlecht.

Ich kann auch jedes Jahr wieder hochzählen, dass wir irgendwann

2020 angekommen sind.

Wenn sich da nichts großartig ändert,

warum nicht, ne? Das wird 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 Mobil springen oder was?

Ich hätte 50 gefunden.

Naja.

Ja.

Was mich jetzt noch interessieren würde,

also auch aus Person.

was wäre denn mit dem nächsten Level?

Also wenn ich jetzt so die ganzen Basics

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 im Notfall was haben.

Also wenn Leute

Fragen zu Themen haben, dann gehen wir da auch

drauf ein oder wenn die irgendwie Projekte haben

oder sowas. Projekte ist vielleicht ein gutes Stichwort.

Das heißt, wenn man bei euch durch ist mit 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? Ja, 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.

Grob

zehn Level. Ich glaube, mit 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 mit Netzwerk. Das waren dann

quasi anfängend,

normalerweise fange

ich immer so an, erstmal

wie macht man den

Brandham-Algorithmus

in Python? Dann google ich das und dann

gehe ich auf Stack Overflow und gucke ich mir an,

Jetzt musst du ganz kurz

für unsere Hörerinnen erklären, was der

Bentham-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ümmert sich jemand anders um.

Ja, aber genau,

wenn ihr sagt, ihr macht eine Funktion,

wie tief geht denn das eigentlich

sozusagen...

Jetzt haben wir ein Rekursionslimit.

Okay.

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 Clutures sind

und solche? Nein.

Also das machen wir irgendwann.

Ich meine, dann 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 das wird später irgendwie 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 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 kommt 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ähnt ist einfach gar nicht.

Ja, aber ganz witzig da auch, weil

ihr beide habt so ein bisschen andere Artenweise,

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 erinnert sich auch

bei der gleichen Person jeden Monat.

Wir lernen

ja auch dazu. Hoffentlich.

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 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 Print-Funktion,

man kann auch einfach hinnehmen,

dass wenn ich da einen String reintue, 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 String

aufgerufen werden und nicht mit einem String,

das...

Es hat bisher auch zum Glück niemand gefragt, warum da

ein Punkt steht.

Das ist so eine

Schwierigkeit, die es mit

Sicht 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 ist das erste Projekt, mit dem ich angefangen habe

war

das 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 einer 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

so einen Commit und bitte guckt euch nicht

auf GitHub an, das ist schrecklich.

Ja, ich glaube, ich habe auch noch

auf meinen GitHub-Repo, in

meinen GitHub-Account

Karteileichen von Projekten, die ich mal

angefangen habe, halbherzig

irgendwann dann

liegen lassen. Da müsste ich, glaube ich, auch mal

auskehren.

Noch diesen einen YouTube-Client, der irgendwann

einfach das Stack-Limit erreicht,

weil jeder Menüpunkt ein neuer

Regressions-Sys. 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,

das dann doch nicht mehr zu machen.

Nee, das, genau.

Es gibt da mehrere, also bei mir

auch, ich hab ganz, ich weiß nicht genau,

ich hab vielleicht so

60 GitHub

Repos oder sowas.

Ich sammle die nicht, aber

im Verlauf der Zeit passiert das irgendwie

und dann gibt es halt unterschiedliche Stadien

in denen sich Projekte befinden können

und die, also

tatsächlich, ich habe auch noch nie ein GitHub-Repo 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!

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 auch keine Software.

Es gibt so eins, da habe ich ein Domain,

da zahle ich jedes Jahr Geld für

und da habe ich keine Software für.

Sehr gut.

Bei einem Projekt,

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... Weil es geht.

Weil es geht, weil 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.

Und ich glaube, nach

Nach ein paar Monaten, wo ich da wirklich hochkonzentriert dabei geblieben bin, bin ich dann in so eine 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 gelassen 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 eigentlich nur ein Projekt habe, an dem ich aktuell arbeite und das halt irgendwie so mal entweder, weil mir das eine irgendwann langweilig wird oder durch so andere Faktoren, wie wenig Zeit oder sowas. Oder Leute sprechen mich mal an mit, hey, was ist denn eigentlich geworden aus? Dass ich das dann so 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 Gruppenoptimierung, wo ich halt immer, wenn ich mal wieder Zeit und Lust habe, dann 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.

Hast du auch Tests?

Tatsächlich habe ich teilweise Tests.

100% Coverage?

Naja, die werde ich niemals erreichen, aber für die Objektorientierung, die da zur Grunde 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 ausgedacht.

getestet oder wir hatten da Donnerstag

darü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 die Sachen

auch vorher mal direkt bei GitHub direkt hochgeladen,

das ist ja interessant. Also ich habe jetzt auch so ein paar Sachen

entdeckt, Bitbucket kennt ihr ja bestimmt alle und

Azure, da gibt es ja jetzt 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.

Ja, das war

früher, war es kostenpflichtig.

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

Nee. Ach so.

Da wollte ich dann auch überlegen, ob ich

mein Gruppenoptimierungs-Repo

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.

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

glaube ich, glaube ich nicht mathematisch, oder?

Nein, nein, nicht mathematisch

Gruppen. Ja, sowieso

Teamzuteilung. Ja, Teamzuteilung.

Hatte ich mir

dann in der Mitte der Entwicklung

dann auch überlegt,

ich weise hier Menschenwerten zu,

ob das noch moralisch vertretbar ist.

Man muss wissen, Dodo macht

Jugendarbeit. Ja, ich mache das mit der

Jugendarbeit und da ist es immer

schwierig, die Teams fair zu gestalten.

Gibt es irgendwelche Sensoren,

die Arbeit übernehmen lassen für die Bewertung?

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

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, Jürgen.

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, dass irgendwie der Weg, wie es eigentlich sein sollte,

irgendwie top-down. Man macht irgendwie

Architektur und überlegt sich, wie Dinge

so funktionieren sollen. Das ist aber schon sehr klassisch.

Man macht sich einen Plan und dann

füllt man das sozusagen nur noch aus,

bis zu, keine Ahnung, wenn ein Konzern,

das habe ich mal irgendwann von Siemens gehört,

dann gibt es dann irgendwie die

Informatiker, die dann halt sich die Architektur

überlegen oder die 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.

Ja.

Ist ja auch ein bisschen eklig.

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

Das 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ür das Plan betrieben hat, erstens dahin und man ist dem Projekt noch nicht so weit.

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

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

Ja, gut, das muss ja nicht komplett ausformuliert werden.

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 bedacht 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 zu strukturieren, weil Struktur sollte es dann am Schluss ja vielleicht schon haben, erst einfallen, wenn man das implementiert, weil viele Dinge, die wichtig sind und man gar nicht weiß, bevor man es nicht gemacht hat und dann erst, wenn man es hinschreibt, merkt man also, oh, das ist mal ganz wichtig.

das 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 eher so im

Nachhinein, wenn man das Problem wirklich verstanden

hat, aber um das Problem wirklich zu verstehen,

muss man irgendwie das schon programmiert haben,

sonst, ja.

Aber gerade so, 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 auch bei 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 in meinem Kopf habe,

sondern es im Notfall auch andere Leute machen könnten.

Kleine To-Do-Liste vielleicht? Ich weiß nicht, ob das

dann schon viel sagen kann.

GitHub-Beschuss.

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 Readme-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.py

tatsächlich die Berechnung durchführen.

Ja, und in der Main.py

werden einfach GUI und Backend

zusammengeführt. Ich habe gerade so ganz

wichtig ist, irgendwie Sphinx oder sowas.

Ja. Und dokumentiert.

Also ich benutze

ja auch tatsächlich Sphinx. Also

Markdown, wird das dann irgendwie

noch in was anderes verwandelt oder?

Nö, ich nehme rohe Markdown-Dateien.

Genau, weil

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, ja, Renderer

irgendwie, der dann halt hinterher entweder

eine Webseite ausspuckt oder ein PDF

oder sonst irgendwas. Und da nehme ich

dann immer noch das, dieses

Read the Docs

Theme dazu.

Es gibt so eine Seite,

das ist eigentlich ganz hübsch und dann,

wenn man dieses Theme mit installiert,

dann sieht die generierte Dokumentation

halt hinterher genauso aus und

man kann sie auch automatisch irgendwie direkt

auf Read the Docs irgendwie hochladen, wenn man

jetzt da in GitHub

so einen Hook aktiviert.

Ich glaube, ich habe bei Sphinx aus

seiner Dokumentation an den einzelnen Funktionen

und Methoden dran, also aus den

Docstrings, 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 irgendwie 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-Videos, wo sich dann

Leute überlegen, wie rufe ich jetzt die Funktion

tatsächlich auf?

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 dann eine Dokumentation,

einen C-Code mit den Funktionen

zu aufrufen, die dann 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.

Wie kann ich jetzt ein abstraktes Modell in meinem Kopf

erzeugen, das ich noch nie kenne?

Whiteboard. Ja, habe ich tatsächlich

eines neben meinem Schreibtisch hängen.

Also auch malen, sagst du. Und dann in kleine

Teile liegen. Also malen

hilft doch ziemlich stark, finde ich.

Wenn man sich 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. Ihr habt leider auch nichts.

Also nicht in ganz reichweite.

Also Schmierzettel, meistens

die Rückseite von irgendeinem Fehldruck

und nehme dann einen Bleistift und male das

auf, weil ich habe tatsächlich

festgestellt, dass ich so deutlich

besser mir Sachen visualisieren kann.

Wahrscheinlich würde das

auch mit einem Grafik-Tablet geben,

aber dafür müsste man ja Geld aufnehmen.

Grafik-Tablets fände ich cool, aber ich

habe bisher noch keins gekauft.

Tatsächlich für das Gruppenoptimierungsprogramm, wenn ich

einmal, da ging es

um den Algorithmus, der tatsächlich

die Optimierung macht, der 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 Team-Schnipsel und dann

habe ich weitere Schnipsel genommen, die wie

Pfeile aussahen, dann habe ich

den Teppich zur Seite gerollt, das alles

auf dem Boden aufgelegt, ein Foto von mir gemacht

und seitdem habe ich im

Repo ein Foto von

Schnipseln auf dem Boden.

Da bräuchte man halt auch Platz auf dem Boden.

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 einem Grafik-Tablet schneller hingekriegt.

Aber

ja.

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 das...

Bei dir per Machine Learning automatisch getaggt und in den richtigen

Ordner...

Das ist alles Handarbeit, aber

was ich auch faszinierend finde, ist,

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 habe, also

meiner Ansicht nach ist es gar nicht so wichtig, was man sich aufschreibt,

sondern allein das vom Papier sitzen

und mit dem Stift da irgendwie was drauf rum machen,

das hilft einem schon irgendwie oder

meinem Gehirn irgendwie offenbar dabei