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.
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
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. Das ist irgendwie komisch.
Also bei mir funktioniert das tatsächlich auch ganz gut
mit Textdateien. Für mich ist es halt nur,
dass ich dann sonst nichts habe. Also ich mache halt
dann wirklich auch auf dem
Bildschirm frei und gucke halt, dass ich wirklich nur
das habe, was ich schreibe. Der Sehen-Modus.
Und dann geht das eigentlich auch
relativ gut, finde ich. Vielleicht ist es 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 am Rechner bin, kann
ich nicht Twitter aufmachen auf dem Whiteboard oder sowas.
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, die wir noch
gewohnt sind, wenn wir was
auf Papier schreiben, dann konzentrieren wir uns
darauf. Ich hasse Papier und Papier hasst mich.
Und wenn wir vor dem 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 so was in 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 ist, dann ist da so eine Wand,
dann kommt man nicht einfach drüber und
Was würdet ihr empfehlen? Wie sollte man da dann
angehen? Schlafen oder irgendwas
völlig anderes machen. Also teilweise
kommen mir die Ideen dann irgendwie auf den Klo oder
unter der Dusche, abends im Bett.
Darüber
schlafen,
davon ablenken, was anderes
machen. 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 ne,
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 Versionsverwaltung,
das heißt, ich kann auch einfach mal
die letzten fünf Commits rückgängig
machen und neu anfangen.
Also darf man...
Ich muss die Funktionen nicht schrittweise
neu schreiben, ich kann jetzt löschen und neu schreiben.
Ich habe 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
ein 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.
Und nochmal das Konzept mit dem Gelernten.
Der sozialkritische Kommentar des Tages.
Ja.
Ansonsten, Wabba Ducking 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 jemand anderen erkläre.
Also das Programm macht das und das
und dann stellt der mir Fragen und wenn
ich die Fragen nicht beantworten kann, dann lerne ich daraus.
Oder auch
Doku schreiben. Das ist so ein bisschen quasi
Faber-Ducking mit sich selbst.
Da fällt mir das dann auch teilweise auf.
So.
Allein schon, weil man dadurch
eine andere Blickweise auf das Problem
bekommt. Und
das hilft einem meistens.
Rubberducking, Gummienten?
Ja. Stell dir vor,
du erzählst es einer Gummientin.
Genau, ich kenne das
als Rubberduck-Debugging.
Sozusagen, ja genau. Man debugt
dadurch, dass man einer Gummienten erzählt,
was da eigentlich passieren sollte.
Und dann, wenn man das 10 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 10 Minuten
sagt man sich, ah, okay, ich weiß, warum es
schief geht, ach Mist.
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 wird wirklich spannend
finden, dann geht es auch mit echten Menschen
und nicht nur mit Gummienten.
Vielleicht geht es auch sogar schneller, aber es geht halt auch mit
Gummienten und das ist halt das Faszinierende.
Irgendeine Art von Gummienten, die ich irgendwo bei mir
über die Jahre... 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 irgendein
irgendetwas nicht bedacht hat.
Gerade Verleitung oder sowas.
Die Fehler sind meistens döver als man selber.
Ja, was weiß ich, da hast du dann irgendwie
eine Klammer vergessen und auf einmal ist das
kein Tupel, sondern
sonst noch was. Oh ja, ich
habe mir ziemlich viel Zeit damit
verständet, weil ich ein Tupel haben
wollte mit einem Element, dann eine runde Klammer drum
gemacht habe und es war dann kein Tuffel, sondern es
fehlte ein Komma.
Ja, wie gesagt, meistens
sind es eben 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.
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 programmiert ist, 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, den 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 ich 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 schnibbel 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 oft diese Momente, aber
oft weiß man eigentlich, was zu tun ist
und muss das halt nur eine Zeit lang machen.
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 wie Wadding, ja, weil du halt da stehst
und du hast ein Rätsel und du knackst es dann
irgendwann halt hoffentlich.
Ja, aber das kann auch ziemlich frustrierend sein.
Ich finde es aber dann als Abwechslung auch ziemlich
entspannend, irgendwie, weiß ich nicht,
irgendwas einzurichten
oder irgendwie Doku zu schreiben oder so, weil du
weißt, du kannst dann halt irgendwie die Zeit
einschalten und du machst das dann halt und hast dann 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 dann, 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.
im Grunde weiß man ja
auch, 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
daran? Also versucht ihr den zu debuggen,
indem ihr guckt, was, also warum
das ist, oder versucht ihr dann auszuprobieren, wie man den
lösen kann? Ich habe noch nie wirklich
einen Debugger verwendet, immer nur Print.
Ja, ich auch nicht. Also
wenn ich einen Syntaxfehler habe,
gut, dann sehe ich im Traceback,
aha, zahle 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, der Fehler muss ungefähr da
sein. Oh ja. Und dann,
okay, das ist jetzt ein Ausdruck der
drei ineinander verschachtelte
Funktionsaufrufe, dann
verschachtele ich die jetzt mal in drei
Zeilen und dann jeweils Print vorher,
Print nachher und
meistens mache ich es dann so plump,
also Debugger...
Also VS 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 Print sich dann immer
einem, den man nicht extra in den Code schreiben
muss, sondern irgendwie einen Debugger und so.
Ja, aber meistens
nehme ich dafür dann auch einfach
einen Print und gut. Und wenn euch nicht
einfällt diese Lösung, guckt ihr dann in die Dokumentation
oder werdet ihr dann einfach angezeigen
in die Modulreihen
oder sowas?
Meistens hilft es auch, wenn man
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 Overflow dieselbe Frage gehabt haben
und
da hilft es meistens auch,
zumindestens, um schon mal zu verstehen,
um was für einen Fehler es
sich handelt. Klar, bei den
normalen Facepacks ist das relativ
simpel. Wenn da Zero Division
Ever 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ühlchen offengelassen.
Das sind natürlich ja gut.
Die
ist eventuell noch nicht gewohnt.
Ein klassischer
Flüchtigkeitsfehler, einfach vergessen.
Das kommt natürlich vor.
Dann gibt es Fehler, die quasi
wir schon wissen, dass die auftauchen
werden, weil
ja
Welche zum Beispiel?
Jetzt wäre ein Beispiel gut.
Wenn man zum Beispiel
die falsche Variable benutzt.
Wenn du in der Vorschleife
statt die Durchlaufvariable
dein Interact
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
dahin schreiben. 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änge machen einfach nur mehr
Flüchtigkeitsfehler.
Die sind das
ja auch nicht so gewohnt.
Wie sieht ein String aus? Ich erkenne
viele Fehler ja tatsächlich auch optisch.
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 jede
Buchstabe für mich quasi
einen Einblick in eine neue Welt gibt,
dann ist das eventuell
schwieriger. Also auch so, dass das
Syntax-Verleitung irgendwie in der falschen
Farbe ist, das fällt mir ziemlich schnell auf.
Ja, weil man da auch ein gewisses
Gefühl
hat.
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
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 String und dann nochmal ein Gänsefüßchen
und dann vergisst es dir einen zweiten.
Oder
der Textor fügt da nochmal zwei ein.
Ja, dann hast du drei
und dann klappt das auf einmal nicht mehr.
Dann laufe ich da 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
die Anfänger besonders toll finden?
Etwas, wo man irgendwie zuverlässig
so einen Wow-Effekt mit erzielen kann?
Oder was sie
überrascht, wie einfach das geht?
Gerade so grafische Sachen sind immer
ziemlich überraschend. Wir haben mal irgendwann
ein Turtle gezeigt.
Und
dass man einfach so
schnell irgendwie, also gerade
so grafische Ergebnisse,
Rechtecke oder so was oder
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,
ich finde bunten Text im Terminal ja spannend,
aber ich finde das
auch schon sehr spannend.
Irgendwie sehen das andere Leute nicht so.
Die Leidenschaft scheint nicht so ausgeprägt zu sein.
Wir haben, glaube ich, mal
einen Abend, Leute, ziemlich stark
gelangweilt, indem wir sehr viel zu Terminals
erzählt haben.
Ich glaube, du warst dabei.
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 Erinnerungen direkt sieht.
Ja, ein bisschen was für die Augen.
Voll die krassen Sachen gesehen, wenn man Blender
machen kann. Man kann halt diese ganzen
interaktiven Grafiken generieren
lassen mit, weiß ich nicht, 20 Zeilen oder so.
Klar, aber dafür müssten wir eine Ahnung von Blender
haben. Tja.
Es 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
ja, hab da jetzt ein kleines Projekt, das
sich mit Steganografie beschäftigt.
Oh. Ja, gerade so
zu den höheren Leveln fehlen uns doch
sinnvolle Beispiele. Ja, das stimmt.
Ja. Aber da kommen wir gerade
ja dazu. Pillo, was sind eure Lieblingsmodule?
Oh. B-Python, ganz klar.
Ja, B-Python ist ja
ein Interpreter. Ja, gut. Aber ich
stimme ja zu, B-Python ist schon ziemlich
cool.
Boah, mein Lieblingsmodul.
Jetzt hat er B-Python
Man sagt ja natürlich nicht einfach auch B-Python
sagen.
Du kannst ja C-Python sagen.
B-Python.
Ja,
Weekfest finde ich ziemlich cool, weil man
damit sehr einfach
halt Netzwerk machen kann.
Gerade auch so, wenn Leute irgendwie,
es gab Leute, die hatten irgendwie so eine
Comic-Seite oder so und da wollten die
irgendwie eine Benachrichtigung haben, wenn es einen neuen gibt
oder sowas. Das sind gerade so Projekte,
die eigentlich einfach sind,
aber dann doch irgendwie überraschend sind.
Gehen glaube ich ziemlich schnell.
Ich glaube, ich...
Waypile, 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
einen großen
ein großes Plus
an Usability und
dafür 56
Zahlen finde ich echt gut, vor allem
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.par
Ja, da war es nicht.
Dateien,
mit Dateien gearbeitet hat und wie
viel einfacher das jetzt mit
Parflip geht.
Das ist Standard-Bibliothek.
Auch da gibt es ja viel zu viele Dinge, die eigentlich cool sind,
die zu wenig bekannt sind.
Jochen, was ist dein Lieblingsmodul?
Mein Lieblingsmodul? Oh je.
Ich weiß nicht.
Ich glaube, Lieblingsmodul...
Ich hätte jetzt auch gar nicht wirklich drüber nachgedacht.
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 zum Beispiel so ORM
verwendet und dann fällt da so ein Statement bei raus
und man guckt sich ja 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, wenn man das Query-Set hat,
Query-Set.Query und dann spuckt das Ding
das SQL-Statement aus, allerdings dann halt so
als langen String, was
relativ unleserlich ist und mit
SQL-Pars kann man halt einfach sagen,
okay, formati 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?
So viel habe ich jetzt doch gar nicht durch, aber ich finde
Kiwi ganz witzig irgendwie, weil das auch
direkt irgendwie so Touch bietet für so kleinen Unsinn.
Wenn man jetzt nicht total die
aufwendigen GUIs bauen will, dann relativ einfach
ganz witzige Lösungen hinbekommen.
Ja, was mir noch einfällt, genau.
Ich weiß nicht, ob wir das schon mal hatten.
Pythonista ist 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 ist 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 ganz toll,
hat auch eine schöne IDE 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++ und C und
was gibt es denn noch, 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,
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
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, 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 Sprechen
mit der REST-IP 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's
auch für Android.
Thermux, das ist... Das ist ein Terminal.
Ja, genau, das ist ein Terminal-Emulator.
Sogar mit Paketmanagement
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 senden oder
sowas. Und es läuft
halt auch Python drauf. Also es kommt halt mit
einem Paket-Repo 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 der GPIO. Also auch
den Raspi oder sowas ist natürlich super.
Ganz viele coole
einfache Sachen machen kann, die man auch super schön
zeigen kann. Also einfach jetzt
ein paar Pinne ansteuern und so Lämpchen zum Bräuchten bringen,
das kriegt auch jedes Kind hin und man hat
da 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 DISS kann ich
mir halt den Python Bytecode für eine Funktion
anzeigen lassen.
Und es ist halt nicht nur einfach die Byte,
sondern es hat auch wirklich die Namen,
die 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.
Im Quatsch ist es.
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.
Zum Beispiel img-hdr, das kann dir ja von einer Bilddatei
sagen, welches Dateiformat das ist.
Also quasi so ein Pfeil-ähnliches
Dingsmus in der Pfeil-Standlage eingebaut.
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.
Ja, da gibt es
andere Bereiche, in denen gibt es dann irgendwie
drei Module, die irgendwie das gleiche
nur auf unterschiedliche Art tun.
Urlib, Urlib 2, Urlib 3.
Einfach Request nehmen.
Und Requests gibt es nicht in der Standardbibliothek und so.
Und das ist schon so ein bisschen...
Also Request ist auch
so das eine Ding, wo ich mir wünschen würde, dass es
eine Standardbibliothek 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 ja halt HTTP for
Humans, ne, irgendwie, wenn man das jetzt als
Anwender, also als Entwickler, Anwender benutzt,
ist das halt sehr praktisch, aber
wenn man jetzt zum Beispiel viele HTTP-Requests
machen möchte oder so, dann ist das halt auch schon
nicht mehr so toll, weil das ist halt nicht
asynchron, also
man hat Multiplex halt sozusagen
I.O. nicht wirklich,
kann das dann eventuell machen, indem man halt
Threads verwendet oder so, aber so
von sich aus kann das das halt nicht
und dann gibt's halt vielleicht
auch, wenn man das halt noch nicht kennt,
AIO
HTTP
ist, glaube ich, die
Bibliothek
oder das Projekt, ich weiß nicht so genau, da gibt es einmal
einen Server, 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
gibt es 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
in Düsseldorf und der Regierung seid, dann kommt doch einfach
vorbei, ne? Genau.
Ja, einfach so. Ich glaube, nicht nur Donnerstags
sind da ein paar Jungs immer da.
Ja.
Ist halt jede Woche.
Ja. Also nicht unbedingt
mit uns, aber ja.
Da gibt es auch
andere coole Menschen.
Ja, kann ich bestätigen.
Ja, wenn ihr irgendwas antragen
wollt, nochmal Events, wieder euer Feedback,
Kommentare an
hallo.peisen-podcast.de
Ja, schön, dass ihr wieder eingeschaltet habt.
Genau, dann versuchen wir mal
irgendwie die nächste Sendung etwas zeitnah
hinzukriegen, aber das... Ja, wir hatten eigentlich schon
etwas vorbereitet, aber das hat nicht so gut geklappt.
Da müssen wir noch mal dran.
Datenbanken, wir können ja schon mal das Thema verraten.
Haben wir uns eigentlich auf die Fahne da geschrieben.
Wer hat eigentlich Model-View-Controller erfunden?
You have to.
Okay. Bis zum nächsten Mal.
Alles klar. Tschüss.
Tschüss.