Transcript: Python in der Wissenschaft

Ja, hallo liebe Hörerinnen und Hörer, willkommen zum Python-Podcast.

Wir haben die elfte Episode heute und sind heute wieder in Jochens Winter-Sommergarten.

Wir haben gerade Sommer.

Ja, hey Jochen, und wir haben heute wieder einen tollen Gast dabei, das ist der Gerrit.

Heute ist unser Thema Scientific Python.

Ja, vielleicht dachte ich erst mal hallo Gerrit kurz und dann...

Oder so Python in der Wissenschaft.

Hallo, Python in der Wissenschaft.

Genau, weil Scientific Python ist ja ein Paket und das wollen wir nicht verwechseln.

Wir reden eventuell auch über Scientific Python, aber...

Ja, vielleicht sag doch kurz auch deinen Hörern, wer du bist.

Ja, ich bin Gerrit. Ich bin von Haus aus Physiker und beschäftige mich hauptsächlich mit komplexen Systemen und deren Anwendung auf diverse Fachgebiete, Neurophysik, zum Teil auch Wirtschaft und zurzeit Biologie und Ökosysteme aus Mikroben.

Mikrobeller-Analyst habe ich mir aufgeschrieben.

Das hast du dir aber ausgedacht.

Wenn überhaupt Mikrobiell.

Okay, Mikrobieller-Analytiker.

Ja, alles klar.

Und ja, nutze dafür Python, um Sachen zu simulieren, um Daten zu analysieren

und manchmal auch, um ganz komische Sachen mit symbolischem Rechnen zu machen.

Und du spielst Golf.

Und ich spiele, ja, also zurzeit eigentlich nicht mehr so viel, aber ich habe Golf gespielt.

Da reden wir, also keine Ahnung, wollen wir direkt darüber, über Golf reden?

Die Code-Golf, ja, kommen wir gleich noch dran.

Wir machen einmal kurz ein bisschen News, wie wir das irgendwie so kennen und dann kommen wir irgendwie zum Topic.

Ja, auf jeden Fall. Dann mache ich hier schon mal die

erste News-Kapitelmarke.

Alles klar.

Ja, was gab es denn so?

Irgendwas wie PyOxidizer

oder sowas vorgestern, so eine News raus.

Ja, das genau.

PyOxidizer ist irgendwie so

eine Software, mit der es möglich

sein soll,

so eine Python-Applikation

ein Standalone-Executable

zu verwandeln, dass man dann einfach irgendwo hinschütten

kann und dann läuft das da. Und das halt

auch auf unterschiedlichen Plattformen, das heißt auf

Unix ganz genauso wie auf

Windows und

das ganze Ding ist irgendwie so Rust-basiert,

also das packt den Python-Interpreter

halt irgendwie in

in

ein Rust-Programm, also das ganze Ding ist

sozusagen irgendwie hinterher das, was auch

dabei rausfallen würde, wenn man einfach ein Rust-Programm

kompiliert

und ja, man kann alle möglichen

Dinge noch mit dazu, man kann auch Rust-Node mit dazu

So kann man tatsächlich Python irgendwo mithin shippen, also man braucht halt

Python mehr mitmachen, wenn man irgendwo

was deliveren will, beendable oder sowas,

auf den Server gehen, hat man das dabei und dann läuft

das einfach direkt oder auf Windows oder sowas,

für irgendwelche Nutzer, die halt damit nichts zu tun haben wollen,

die füllen dann die SpyOxygen aus und sind dann direkt...

Ja, also das hatten wir letztes Mal auch schon

und darauf nimmt

auch quasi dieses

Announcement, der Announcement-Blog-Post,

den ich da heute gesehen habe,

Bezug, dass es für

Python keine so richtig konsistente

Story

dazu gibt, wie das denn jetzt

irgendwie installiert wird auf einer Maschine.

Das wäre wie so ein Black Swan, also eine der

großen Bedrohungen, die so der Python-Community

vorstellt. Das ist tatsächlich genau. Und da gab es

einen Vortrag, also das war

die Keynote von der diesjährigen

PyCon US

von Russell

Keith McGee, der sagte, naja, das

ist halt eine potenziell fatale

Bedrohung eigentlich für Python als

Sprache, dass das irgendwann mal den

Zugang halt abschneiden kann zu allem.

Also auf mobilen Geräten

ist es ja jetzt schon im Grunde so. Da kommt man halt mit Python

nicht drauf. Und

ja, wenn man

keine solche Story hat, dann ist das halt echt

blöd unter Umständen. Also es macht für Entwickler nicht so

einen Unterschied. Das ist ja auch die Hauptzielgruppe,

da ist es dann egal. Da macht man sich sein

Virtual Environment und

benutzt Pip und vielleicht noch ein paar

andere Tools und so und hat damit kein Problem.

Aber wenn man jetzt einen Endanwender hätte

draußen, der... Ja, der will vielleicht gar nicht wissen,

was für eine Sprache dahinter steckt. Genau, dem interessiert

das nicht, ob das Python ist oder C.

Genau, genau. Der möchte einfach

nur irgendein Problem gelöst haben und gar nicht

ein Problem bekommen zusätzlich.

Und das ist natürlich momentan

so ein bisschen doof, gerade für Windows.

Also für Unix gibt es da ja schon was.

Also ehrlich

gesagt weiß ich davon auch nur, weil

derjenige, der das

entwickelt hat, hier auch

in Düsseldorf oder die

Düsseldorfer Python User Group

irgendwie

gegründet hat oder betreut

irgendwie

Markentree Lemberg und

der hat, genau, das ist uralt,

das ist irgendwie schon 20 Jahre alt oder so.

Ja, ist schon ein 90er schon.

Python 1, was war das?

Ja, ich weiß es nicht mehr genau, aber es ist auf jeden Fall schon

sehr alt und war halt,

er hatte das irgendwann mal geschrieben, um

damals

die ganzen Hoster konnten nur

Perl, irgendwie da Perl war davor installiert

und, aber man konnte mit

CGI auch beliebige

Programme sozusagen hochladen

per FTP irgendwie auf seinen Webspace

und wenn das halt ausführbar war, dann

hat das halt auch funktioniert

und er hat dann halt ein ganzes Python

und seine komplette Applikation halt

in ein Executable reingepackt

und das dann halt als CGI-Ding laufen

lassen können und konnte dann halt auch

auf einem Hoster, der eigentlich nur ein Perl konnte

oder so, halt sein Python

seine Python-Skripte hosten und

ja, das

hat auf Unix schon immer super funktioniert

ist jetzt auch inzwischen irgendwie

läuft das auf aktuellen Python-Versionen

Also ich glaube, seit dem letzten PyTDF-Sprint auch auf 3.7.

Und das ist ziemlich nett, das Ganze.

Man kann da sogar noch so nette Dinge machen wie,

da das, es beruht irgendwie darauf,

dass man, glaube ich, das Modul,

das irgendwie ausgeführt wird,

oder der Entry Point ist halt irgendwie in einem Zip-File,

das halt...

Das hört sich jetzt gerade ein bisschen kompliziert an.

Also was man tun kann, ist, man kann halt

eigene Sachen per ZIP irgendwie

einpacken, dann per Cut hinten an das

Binary dranhängen und dann wird das halt ausgeführt zum Beispiel.

Ah ja, cool, also eigene Pakete

und so. Ja, weil das

Binary irgendwie selbst hinten dran

schon ZIP ist oder ich weiß es nicht mehr genau.

Also man kann damit sehr, sehr lustige Dinge tun

und von der Größe her,

wenn man das

irgendwie so ein bisschen optimiert, dann

ist das, glaube ich, irgendwie so knapp 5 MB

groß oder so, was dabei rausfällt normalerweise

und da ist halt die Standard-Bibliothek nicht komplett drin,

aber zum großen Teil.

Ja, und ich weiß

jetzt nicht, hab jetzt... Ja, aber jetzt kriegst du eine nette Alternative,

das hört sich ganz nett an, ne?

Genau, der Vorteil bei PyAxidizer

ist halt, dass das auf Windows halt auch funktioniert,

was mit PyRun halt nicht geht.

Hat jemand von euch von der PyCon

2019 irgendwelche Talks gehört,

Talks gesehen, irgendwas Interessantes noch mitgebracht?

Also ich hatte einige Sachen gesehen, die ich mir natürlich

wieder interessierte, war irgendwie, dass ein bisschen Musik wieder

was dabei war mit Foxtrot von Jessica Garson,

war ganz nett.

Den hast du aber dann gesehen quasi tatsächlich.

Ja, ja, ich habe irgendwie aber nur kurz reingeguckt.

Ich muss das immer noch auf meiner Liste zu Ende schauen.

Das gibt es ja da irgendwie auf YouTube so ein bisschen.

Ja, und ich habe gehört, Pinterest ist jetzt bald Python 3 oder so.

Ach, ich dachte, die wären schon längst irgendwie umgestiegen.

Aber das war dann wahrscheinlich irgendwie Instagram oder so.

Da gab es so eine Riesendamme, die auch viel zu veröffentlicht, glaube ich,

wie sie da umgestiegen sind.

Aber bei Pinterest, dass die auf Python 3 umsteigen,

ist natürlich jetzt irgendwie so ein bisschen...

So wirklich angeben kann man damit jetzt nicht.

Die letzten, die so umsteigen.

Ja, ich habe gehört, also

der Python-Fu, also der Niklas, der war

jetzt auch schon einmal bei uns hier.

Die haben jetzt ein Tutorial für Python 2.7

und der Python 3 veröffentlicht. Das fand ich

sehr lustig.

Ja, und auch diese Woche.

Ja. Nee, aber ansonsten

habe ich auch tatsächlich im Grunde nichts

wirklich, was irgendwie an tollen Dingen

passiert wäre.

Aber immerhin ist ja schon so ein bisschen

was. Ja, so ein kleines bisschen.

Sonst machen wir dann nächstes Mal einfach wieder eine große News-Section und

fangen jetzt einfach an mit unserem Scientific-Thema.

Oder wollen wir erst mal mit dem Golf spielen?

Also spielst du auch richtig Golf oder nur Code-Golf?

Nee, ich spiele, wenn überhaupt, Code-Golf.

Zurzeit auch ehrlich gesagt nicht mehr so viel.

Irgendwann, wenn man das so ein paar Jahre

gemacht hat, hat man alles gesehen, was es

zu sehen ist. Jetzt erst mal für die

ungebeten Hörer, was ist das denn überhaupt?

Code-Golf. Also Code-Golf ist die

Aufgabe, dass man versucht, irgendeine

Programmieraufgabe, zum Beispiel programmiere die

Fakultät oder was auch immer,

mit möglichst wenig Zeichen zu lösen

in einer gegebenen Programmiersprache in der Regel.

Oder man kann es auch allgemein machen,

aber da wir jetzt über Python reden

und für die meisten Leute das Interessante ist,

in einer Programmiersprache zu machen.

Und ja, ohne Rücksicht auf irgendwelche Regeln.

Und das kann Spaß machen, offensichtlicherweise,

dass man einfach mal alle Regeln fallen lassen kann

und wild böse programmieren kann.

Ich kann mich noch daran erinnern,

ich saß mal in so einem Talk von dir,

da war ich immer noch ein absoluter Anfänger

weil ich habe nichts verstanden von dem, was du da erzählst.

Irgendwas funktionierte da, aber dann irgendwie, ja,

okay, warum machen wir das jetzt? Keine Ahnung.

Und ja, also die zweite Sache, warum man es macht,

wenn wir mal dabei bleiben, ist,

dass man auch wirklich was über die Programmiersprache lernt

oder über das Programmieren im Allgemeinen,

weil man eben auch darüber nachdenkt,

gewisse Probleme mit ganz neuen Algorithmen zu lösen,

zum Beispiel rekursive Algorithmen

statt irgendwelchen Schleifen oder, oder, oder.

Und ja, das macht einfach sehr viel Spaß,

wenn man das ab und zu macht und man lernt auch viel.

Da gibt es auch so Wettbewerbe oder sowas, ne?

Ist das so richtig mit 18 Löchern oder wie spielt man das?

Ne, also es gibt natürlich Webseiten,

wo man dann seine Lösung veröffentlichen kann und dann sagen,

okay, ich habe das jetzt kürzer gelöst als alle anderen

oder zumindest kürzer in dieser Programmiersprache gelöst

als alle anderen.

Hast du da eine Shownote für uns, für eine Webseite?

Es gibt eine Stack-Exchange-Seite zum Thema CodeGolf.

Das ist auch die, wo ich hauptsächlich aktiv bin oder war.

Ja.

Es gibt andere Seiten, aber da muss ich ehrlich gesagt sagen,

weiß ich gar nicht so viel drüber.

Okay.

Und

jetzt schau doch mal mit Stecken-Change vorbei für

Kotgolfen. Ja, wie gesagt, ich packe

den Link dann einfach dazu. Und was sind

so deine, hast du vielleicht Lieblingsaufgaben

oder so, oder was besonders

irgendwie interessante, einen interessanten

Lösungsweg hatte? Also, ja, also

interessante Lösungswege,

ja gut, ich bin,

komme aus der Physik-Mathematik-Ecke, also kann man,

finde ich immer froh, wenn ich Sachen mit

komplexen Zahlen oder so lösen kann.

Also klassisch sind irgendwelche

Aufgaben, wie irgendein Objekt bewegt sich in irgendeinem Raum oder irgendein Robot oder was auch immer und man muss den steuern und das kann man natürlich machen, indem man zweidimensionale Koordinaten speichert. Das ist in der Regel aber kürzer, wenn man das Ganze in komplexen Zahlen löst und ja, da gibt es dann einige Aufgaben, wo man das sehr lustig lösen kann und am Ende natürlich überhaupt nicht mehr, wenn man nicht eingeweiht ist, versteht, was da eigentlich passiert.

und

ja, also ansonsten

ich kann, keine Ahnung, ich glaube das Interessanteste

was man jetzt so auf dem

diesem Medium überhaupt kommunizieren kann

sind dann vielleicht so ein paar Tricks

die man nutzen kann

also ein klassisches Beispiel

ist natürlich, wenn ich irgendwas habe, muss ich irgendwas in einer

Schleife lösen, das kann man natürlich auch so machen

häufig ist es dann aber so, dass diese Schleife

vielleicht nicht so

spannend ist, also dass da jetzt nicht so viele

komplizierte Dinge passieren und dann könnte es

zum Beispiel einfacher sein

den Befehl, den man in der Schleife ausführt,

in einen String zu packen,

diesen String zu multiplizieren,

also mit Semikola getrennt, mal

fünf oder so, weil ich das fünfmal ausführen möchte

und dann ein Exek darüber zu jagen.

Also genau,

die ersten

Jochen

hingen sich schon die Fußnägel hoch

und ja,

das ist dann, genau solche Sachen

passieren dann andauernd, dass man irgendwie

feststellt, wie wenig Leerzeichen man

eigentlichen Python braucht, wenn man denn

unbedingt möchte. Also es gibt so Späßchen,

dass man, wenn man

hinter irgendwo

eine Klammer aufhört oder dahinter kommt ein

Keyword oder so, dann kann man die einfach direkt

aneinander schreiben

oder zahlen oder

eigentlich irgendwas. Ich glaube, das ist der einzige Unterschied. Man muss immer aufpassen,

wenn es mit e anfängt, weil das könnte ja 1

e 8 wäre dann 10 hoch 8.

Das darf man dann nicht machen, aber alles andere kann man

einfach wild aneinander klatschen

in vielen Fällen und es wird richtig interpretiert.

Dann gibt es, ich glaube in Python 3 funktioniert das nicht mehr, in Python 2 funktioniert das noch, dass man verschiedene Eindrückungsebenen mit Tab und Leerzeichen hat. Also die erste Eindrückungsebene wäre ein Leerzeichen, die zweite Eindrückungsebene war ein Tab und dann kam irgendwie ein Tab und ein Leerzeichen als Eindrückung und so weiter. Aber gut, wenn man dreimal einrücken muss, dann ist es in der Regel kein CodeGolf mehr.

Ja, genau. Muss man denn überhaupt einrücken?

Ich meine, es gibt doch Semikolon, das ist doch auch gut.

Man muss es manchmal schon machen.

Also manchmal ist es schon das Beste,

aber zwei Einrückungsebenen sind schon sehr,

das sind dann schon, wie ich ausgefallen habe, Programme.

Da kann man dann schon die ganze Fakultät mit abwenden.

Und ich meine jetzt nicht das mathematische Problem,

sondern das, was man in der Uni dann so besucht.

Ja, okay.

Und das heißt, du machst dann sowieso nur ein Name.

Also lesen kann man das dann wahrscheinlich nicht mehr?

Sondern es geht tatsächlich darum, in wie viel Byte

passt denn dann so ein Algorithmus? Genau, also

lesen ist die eine Sache, die man nicht mehr kann. Manchmal

hört das auch gar nicht auf. Also auch so die

klassischen Ansätze für viele Sachen sind, dass man

jetzt sagen kann, okay, ich kann jetzt

meine Daten,

ich kann jetzt einen interessanten

Algorithmus entwickeln, der die richtige

Lösung für irgendwas findet.

Ich kann aber auch,

jetzt weiß ich gar nicht, ob es Bogosort oder Stupid Sort

oder, ja, ist auch egal, es gibt diesen klassischen

Sortieralgorithmus. Ich

nehme meine Daten, ich mische sie,

ich gucke, ob sie sortiert sind, wenn nicht, wische ich sie nochmal.

Ja, ja, ja. Solche Ansätze

und, ja, wenn

dann die Aufgabe nicht vorgibt, dass man das

Ganze in einer endlichen Zeit lösen möchte, geht

das natürlich.

Das ist auch immer eine, ja,

ein Lieblingsansatz, dass man sagt, okay,

wir versuchen das jetzt schön

in Brute Force

zu lösen, statt, weil

an der gewissen Wahrscheinlichkeit ist

das dann sofort fertig.

Ja, ich habe letztens auch

irgendwo neun, es gibt ja diverse

lustige Sortierverfahren. Ich habe

letztens eins gesehen, das fand ich auch wieder sehr cool.

Sehr schön. Das besteht einfach

darin, ich glaube, das nennt sich irgendwie Sleepsort.

Und wenn man halt

Zahlen hat, dann macht man das mit

Async

Await-Notation.

Man awaitet einfach die Zahl.

das ist dann halt sortiert, weil

naja, je größer die Zahl, desto länger

wartet man halt.

Das ist auch

sehr, sehr cool.

Mein Lieblings-Sortiere-Algorithmus ist der LSD-Radix.

Das ist so schön.

Der hört sich auch besonders toll an, wenn man den so visualisiert.

Äh, audifiziliert, wie nennt man das?

Wenn man so einen Algorithmus...

Es gibt ja so einen...

Vertont.

Ja, ja, ja, wahrscheinlich.

Vertont.

Gut.

Ja, wir vertonen für euch ja wieder heute eine neue Folge.

Ja, jetzt habe ich keine Ahnung, was LSD-Radix macht, aber gut.

Der baut so Buckets auf und sortiert dann die ganzen Sachen immer in so Buckets rein

und gibt die dann immer wieder auseinander.

Okay.

Ja, also von 0 bis 1.9 oder sowas.

Und dann kippt er die auseinander.

Und dann funktioniert das für mich ganz gut.

Eine Sache, die mir jetzt noch gerade eingefallen ist,

man muss sagen, wir warten auf die Eingabe und wie lange es dauert.

Also auf CodeGolf StackExchange gab es dann auch zwischendrin mal

so eine Kategorie von Fragen,

die haben wir uns auch ganz schnell ausgedruckt und abgeschafft.

Wir versuchen jetzt mal eine Programmieraufgabe

möglichst schlecht zu lösen.

Also nicht schnell oder kurz oder was auch immer,

sondern einfach schlecht.

Und dann die Aufgabe, einen Zufallszahlengenerator zu bauen.

Und ja, meine Lösung war dann, wir nehmen, wir speichern einfach mal irgendwo ein Bit ab, lassen einen Zähler hochlaufen und überprüfen nach jeder Zahl, ob das Bit sich eventuell geändert hat.

Und wenn sich das Bit ändert, durch Höhenstrahlung oder was auch immer, dann nehmen wir die Zeit und dann haben wir unsere Zufallszahl.

Das erinnert mich so ein bisschen an deinen Wartsortier-Algorithmus.

Ja, das klingt gut.

in einer besonders chaotischen Umgebung könnte das

relativ schnell passieren.

Wie ist das eigentlich bei so

Code-Golf-Community? Macht die nur

Code-Golf? Es gibt ja noch so andere lustige

Programmier, weiß ich nicht,

ich soll mal sagen, so, ja,

Knubelecken. Ja, also die machen

auch andere Sachen. So Quines zum Beispiel

oder Programme, die sich selbst

ausgeben. Oder auch Code-Golf mit Einschränkungen.

Also man kann natürlich immer Code-Golf machen, aber

auch so lustige Sachen war es noch eine Aufgabe.

Multipliziere jetzt mal bitte zwei

Zahlen, aber verwende im ganzen Code keine

einzige Zahl.

Dann muss man

erstmal die Zahlen irgendwie in römische Zahlen darstellen,

also so i, i, i, i, i, ja, ist dann halt

5 und dann kann man da

auf Basis, basiert natürlich multiplizieren und

am Ende kommt dann halt wieder eine Zahl raus.

Man muss halt irgendwie auch gucken, wie

man das mit der Darstellung macht, dass man das dann

regelkonform macht, aber

i, i, i, i, i, i ist 5,

i, i, i, i.

Ja, römische Ziffern, Rechner mit

römischen Ziffern, sehr, sehr böse.

Ja, ja, x, x, x.

Ich habe irgendwann mal auch, glaube ich,

im Blogpost dazu gesehen, wie jemand irgendwie mit römischen

Ziffern schriftlich dividiert hat und das war echt so.

Also, sagen wir mal so,

es ist nicht so unmittelbar einleuchten,

wie das funktioniert.

Ja.

Aber, ja.

Ja, so Kotkolben

ist im Prinzip so eine Absatzionsebene, um

mit der Sprache Schabernack zu treiben, also um

die Komplexität von Algorithmen zu ergründen

und um vielleicht so ein bisschen die Geschwindigkeit

da so rauszuholen und vielleicht auch sowas

Ja, oder auch die gerade, also sich einfach so Gedanken zu machen, also sowas wie SlowSort oder SleepSort oder was auch immer sind ja Sachen, die einfach existieren, dass man sich, dass man überhaupt erstmal sieht, wie gut man es hat und wenn so echten Sortieralgorithmen und auch einfach das Konzept eines Algorithmus besser versteht und ja, also man, genau, man, es ist natürlich einfach, ja, also wie du schon sagst, man beschäftigt sich mit den Dingen und es ist einfach eine Möglichkeit, sich selbst dazu zu treiben, sich mit den Dingen zu beschäftigen und ja, man lernt einiges über Algorithmen und ähnlichem.

Ich habe tatsächlich einen Algorithmus, den ich

begegnet bin, auch tatsächlich später eingesetzt

in echter wissenschaftlicher Arbeit

und war dann sehr froh, dass ich

ihn kannte, weil

ja, also man

Ja,

du hast das Thema tatsächlich direkt fast

schon wieder mit aufgemacht und ich glaube, es ist Zeit für den nächsten

Chapter, Marc. Wenn du das sagst,

du hast ihn jetzt scientific in der wissenschaftlichen Arbeit

eingesetzt. Was ist denn jetzt

Scientific Python? Also das ist nicht SciPy

oder was du eben gesagt hast, sondern

was bedeutet das und warum

macht man das, was macht man da und warum

ist das so nett oder doch nicht?

Also erstmal natürlich als Wissenschaftler

hat man in der Regel, oder nicht in der Regel,

also viele Wissenschaftler müssen

programmieren, zwangsläufig, weil

sie sichern, simulieren oder Daten

analysieren in großen Mengen und

das nicht per Hand machen möchten, aus gutem Grund.

Also quantitative Analyse und

keine qualitative Analyse, würdest du jetzt sagen,

ist die wahre Kunst der Wissenschaft?

Ja, also

ich glaube, gibt es so richtig

qualitative, rein

qualitative Arbeit gibt es

zumindest in meinem Bereich kaum.

Ich kenne noch die alte

Philosophische Fakultät an meiner Universität.

Die hat sich durchaus damit hervorgetan.

Ja, ja gut, aber das ist

ja auch nicht mein Bereich.

Also klar, es gibt natürlich

Bereiche, in denen das

gibt und es auch sinnvoll ist und schön und gut, aber

also ich habe, ich glaube

nicht, dass ich jemals hier irgendwas

beruflich begegnet bin, das

rein qualitativ war. Okay, also ein

ZDF, Scientific Price, also Zahlen, Daten, Fakten.

Ja.

Es geht nicht nur darum, Zahlen auseinanderzunehmen.

Manchmal geht es auch um Zahlen zu produzieren

oder irgendwie einfach etwas,

was man mathematisch, theoretisch zumindest,

theoretisch aber, beweisen könnte oder verstehen könnte,

aber zu kompliziert ist,

dass man es mathematisch zerdröseln kann,

zu simulieren und dann auf die Weise zu verstehen.

Also viele Sachen, die ich gemacht habe,

würde ich als Experimentalmathematik bezeichnen.

Also ich stelle experimentell mathematische Aussagen fest.

Ja, und dazu muss man natürlich programmieren

und das macht man natürlich gerne in Python,

also zumindest ich, anderen natürlich nicht.

Das muss man so ein bisschen Überzeugungsarbeit leisten,

weil es zum einen häufig nicht um Geschwindigkeit geht,

sondern eben darum geht, die Sachen möglichst schnell

und anschaulich zu programmieren und zu verstehen,

was man eigentlich tut.

Zum anderen natürlich, manchmal geht es auch um Geschwindigkeit und da sind viele, viele Aufgaben, die man hat mit solchen Tools wie NumPy lösbar, die die entscheidenden Sachen, die dann wirklich schnell laufen müssen, in einer hartgecodeten, schnell laufenden Variante machen. In einigen Fällen gibt es da nicht und das war dann auch bei mir der Grund, warum ich so eine Sache dann selbst geschrieben habe, um nochmal irgendwie so eine Überleitung in den Raum zu einem gewissen Thema zu schmeißen.

Ja, ja, ich wollte gerade noch auf die experimentale Mathematik, also ich weiß nicht genau, ob ich das jetzt irgendwie falsch assoziiere, wenn ich, experimentelle Mathematik fand ich auch immer sehr interessant, weil ich fand, das war immer so eines der besten Argumente dafür, dass Mathematik unabhängig davon existiert, also nicht wirklich erfunden wird von demjenigen, der sie betreibt, sondern eher so auch entdeckt wird, dass man da halt, also wenn man jetzt einen Computer losrennen lässt und der würfelt halt so lange Gleichungen durcheinander, also bis er halt einen Pfad gefunden hat von dem, was man,

irgendwie zeigen möchte

zu irgendwie einfachen Sachen, die schon

bewiesen sind, also das

kenne ich jedenfalls, oder habe ich mal gehört, dass

Leute so experimentelle Mathematik

nennen, also man

sucht halt einfach quasi

in dem Baum

aller, oder in dem Graphen aller Umformungen,

die man halt irgendwie machen kann, halt

nach einem Pfad von Sachen, die man schon

bewiesen hat, zu einer Geschichte, die man halt beweisen

möchte oder so, dann sieht es halt dann doch eher so aus,

als ob man das entdeckt, halt

wie mit einem Mikroskop oder so und nicht so sehr

irgendwie konstruiert.

Aber...

Das fällt dann unter Computerbeweise.

Das ist manchmal das, was ich jetzt...

Also das ist wahrscheinlich

auch nicht unzutreffend. Der Begriff

Experimentalmathematik ist nicht

kopiergeschützt oder

getrademarkt von irgendwem, der sagt, das ist jetzt genau

das.

Die Sachen, die ich mache, sind da schon

gemacht habe oder auch noch mache, sind auch schon anders.

Da geht es dann eben um die Frage,

wie verhält sich jetzt

dieses Modell, wenn ich das lange

laufen lasse und dann hat man eben

also so klassische Beispiele für

wie Modelle, die meisten

Modelle, Aufstellung oder die

kann man als Gleichung formulieren, das ist eine

Differenzialgleichung in der Regel oder

ähnliche Sachen, also für die Leute, denen es was sagt, man hat

eine Gleichung und die Lösung ist

dann, wie verhält sich mein

Objekt, mein System

über die Zeit. Das wäre die Lösung für meine

Gleichung. Und diese Lösung

kann man in aller Regel nicht

mit Stift und Papier finden, so wie was

Leute normalerweise tun. Also man kann es schon

machen, aber... Dauert dann ein bisschen.

Also auch das ist dann nur eine Annäherung.

Man braucht die richtige Intuition für die Bewegung

der Funktion. Nee, also das

in Zeitfall geht es wirklich nicht.

Wir haben zumindest seit 100 Jahren

keinen Weg gefunden, das zu machen. Man kann eben

höchstens eine näherungsweise Lösung machen und auch das will man nicht

mit Stift und Papier machen. Das ist dann sehr automatisiert.

Das macht man dann mit dem Computer und natürlich

dann wieder mit Programmierung.

Und ja, dann kann

man eben herausfinden, okay, wenn ich diese Sachen

habe, dann verhält sich

dieses System so und so.

Ich kriege so eine Lösung raus, das ist

ein klassisches Beispiel, das ist chaotisch.

Und das ist meine Aussage. Und die habe ich dann

experimentell gefunden,

in gewissem Maße, über Simulationen.

Und diese Aussage ist auch nicht

so in Stein gemeißelt, wie es

normale mathematische Aussagen sind, sondern

das kann immer noch schiefgegangen sein, weil

ich gerade ganz komisch

meinen

Programmlauf in der Sache habe, mit genau den falschen

Startbedingungen oder was auch immer und mein Algorithmus.

Ja, weil man in irgendwelche numerischen

Geschichteninstabilitäten gelaufen ist

oder weil...

Also gut, das kann man sogar noch lösen,

aber weil man einfach

ganz, ganz viel

Pech hatte zum Beispiel. Natürlich, also

die meisten Aussagen, wenn man sagt, das ist jetzt

Chaos, sind schon

sehr, sehr hieb- und stichfest, aber

es ist kein formeller Beweis, wie

Mathematiker ihn führen.

In den meisten Fällen. Natürlich gibt es dann auch die Leute,

die sich hingesetzt haben und das mal für einen Fall wirklich

bewiesen haben.

Das war dann auch eine Sensation oder so, hat auch ein paar Jahre gedauert, aber das ist nichts, was man praktisch machen kann und das war auch dann nur für die einfachsten Systeme, die man schon vorher sehr gut verstanden hat.

Ich habe jetzt diesen ganzen Absatzionslayer

noch nicht so ganz begriffen.

Also man hat jetzt ganz komplexe, große, komplizierte Systeme.

Und wenn ich mir das jetzt irgendwie vorstelle,

du sagst irgendwas von Chaos,

du sagst sowas über Zeitstrahlen und Funktionen,

die da irgendwie durchläuft,

da denke ich irgendwie immer an sowas wie eine Häufigkeitsverteilung

oder sowas, was da irgendwie rauskommt.

Was hat das, also wie kann ich das so real beschreiben,

wenn ich jetzt irgendwie jetzt Mikrobialen ...

Machen wir mal ein Beispiel.

Also ich habe, genau, ich habe Bakterien zum Beispiel.

Also ja, ich mache mal ein bakterielles Ökosystem.

also ich habe meinen Topf,

da schmeiße ich, da habe ich Nährstoffe drin, das heißt

Bakterien können da leben und da schmeiße ich

jetzt, was weiß ich was,

fünf Escherichia coli

oder zehn Pneumokokken

oder was auch immer mir einfällt rein.

Irgendwelches ungesunde Zeug, genau.

Haben wir aber übrigens überall

nebenbei, also wir tragen mehrere

Kilo Bakterien mit uns im Darm rum.

Und noch dreimal Karies.

Ich weiß gar nicht, ob das ein Bakterium ist,

oder was das ist.

Pulbactus? Ich habe keine Ahnung.

Das sah einmal beim Zahnarzt früher so aus.

Da gab es dann diese Psyche.

Die liefen dann irgendwelche Dinge.

Die sahen so aus, wie ich mir Bakterien vorstelle.

Genau. Also die laufen dann auf jeden Fall

da rum und

jetzt kann ich natürlich das einfach

hinstellen und warten und gucken, aber

das kann ich nur begrenzt

häufig machen, da das Zeit kostet und ich

kann auch, habe dann Messfehler

und Rauschen und so weiter und so fort. Aber ich möchte

das eventuell einfach mal allgemein verstehen.

Wie entwickeln sich solche Bakterienpopulationen?

Hört sich jetzt doof an, also du hast es gerade gesagt, es gibt irgendwie so Sachen im Darm, das heißt ihr macht dann so einen Auszug und stellt das in so ein Glas auf den Balkon in die Hitze und guckt, was da so passiert.

Ja, das wäre so die Karikatur des Ganzen, aber es ist gar nicht so falsch, also viel ist wirklich, wir haben einen Topf Flüssigkeit, da sind Nährstoffe drin, da schieben wir ein paar Bakterien rein, das rühren wir dauerhaft um und dann gucken wir mal, was passiert.

Also das ist schon sehr, sehr häufig.

Und danach macht ihr irgendeine Analyse mit,

ich weiß nicht, ihr kippt das Ganze auf Papier,

kommt euch die Farbe an oder zählt irgendwas mit irgendwelchen Sensoren

und packt das in eine Datenbank

und daraus schmeißt ihr dann einen Algorithmus.

Nein, das wäre das, was wir eigentlich modellieren wollen.

Also das ist unser reales System.

Da wissen wir, was passiert, da können wir das messen.

Das Problem ist, das hat natürlich diverse Nachteile.

Wie gesagt, wir können nicht alles messen.

Das ist nur ein Glas und nicht eine echte Haut oder sowas.

Ja, das ist der andere Nachteil.

Aber der Nachteil ist,

wir müssen eben wirklich dieses Glas auf die Fensterbank stellen.

Und im Computer können wir das eventuell in einer halben Sekunde einfach mal durchrechnen und dann können wir das noch schnell 10.000 Mal machen und besser verstehen.

Virtuelle Bakteriengläser, schön.

Genau.

Das heißt, wir haben die ganzen Bugs hergekommen.

Ja, genau. Deswegen, ich bastle virtuelle Bakteriengläser und diese virtuellen Bakteriengläser werden dann beschrieben durch Gleichung.

die zum Beispiel bei Differenzialgleichen

wäre die Frage, okay, ich habe jetzt meine Bakterien,

mein Zustand, mein Zustand ist dann

fünf von der Sorte, sechs von der Sorte, sieben von der Sorte,

so viele Nährstoffe und so weiter und so fort.

Und die Frage ist, wenn ich jetzt eine Sekunde

in die Zukunft gehe, wie sieht mein Zustand aus?

Vermehren sich einige von diesen Bakterien, werden

einige Nährstoffe gefressen und so weiter? Das kann ich

dann machen oder

ausrechnen und dann mache ich das noch mal

und noch mal und noch mal und noch mal und

die Frage, wie man das richtig macht, ist

ja, da haben sich Menschen schon

hundert Jahre lang mit beschäftigt und

gute Wege herausgefunden, das zu machen

und die kann man dann natürlich auch implementieren und das nutzen.

Also die haben quasi das Rezept, den Algorithmus

schon entwickelt und den wird dann

in Python irgendwie übertragen, auf das Modell

angewandt und dann gibt es eine zufällige

Verteilung, die rauskommt. Oder hast du dann immer konkrete

Ergebnisse? Das könnte zum Beispiel

rauskommen, okay, diese Population stirbt

aus und diese Population geht

auf genau diesen Wert und bleibt da.

Und du hast eine Zeit, in der das passiert ist. Und ich habe die Zeit,

in der das passiert ist. Ja, das ist in vielen Fällen

gar nicht mal so das Interessante, aber es ist auch

interessant. Die andere

Sache, die halt rauskommen kann, ist zum Beispiel, okay, es geht

nicht einfach auf irgendeinen festen Wert, sondern es

oszilliert wild rum, zum Beispiel

chaotisch.

Und dann

können wir eben das feststellen, okay, es

oszilliert rum. Das ist eine

Antwort. Oder es ist was anderes, als wenn es

konstant bleiben würde.

Und ja,

wir können uns dann die Frage stellen, okay,

unter welchen Bedingungen oszilliert es rum? Welch viele

Bakterien, Spezies überleben?

Unter welchen Bedingungen? Wovon hängt

das ab? Wie beeinflussen die Bakterien,

Spezies einander? Und

ja, wie verhalten sich eben solche

Systeme im Allgemeinen?

So ein geschlossener Game-of-Life-Kreislauf.

Ja, und ein bisschen realistischer.

Aber ja, Game-of-Life ist auch durch.

Echte zelluläre Automaten.

Ja, nur dass wir halt nicht mehr, ja, also zelluläre

Automaten sind halt ein Typ von Simulation,

Differenzialgleichungen sind ein anderer Typ, dann können wir noch

ja, diverse andere

Typen durchsprechen,

wie wir es lösen können, aber ja.

Und dann kann ich

am Ende sagen, ich weiß, wenn ich

Bakterien so und so zusammen packe,

dann passiert wahrscheinlich sowas.

Das ist das Fernziel dieser

ganzen Forschung, dass man eben

besser versteht, wie sich solche Systeme

entwickeln und dann natürlich auch die Frage, wie reagieren

sie auf Aumwelteinflüsse. Eine häufige Frage ist

zum Beispiel Antibiotika. Ich habe

ein klassischer Fall, wo wir

kein Ökosystem haben im Körper. Was die Ausnahme

ist, ist die Blase. Das ist

normalerweise bakterienfrei,

soweit man das bisher weiß. Steril.

Steril, ja, genau.

Aber wenn da was reinkommt,

hat man ein Problem. Und manchmal kommen da mehrere

Dinge rein und dann ist die Frage, begünstigen die einander?

Bekämpfen die einander?

Sind da verschiedene Bakterien,

die Fressfeinde oder was auch immer sind?

Fressfeinde hat sich toll angefragt.

Befressfeind ist in dem Fall das falsche Wort eigentlich.

Also die ungleichen Nährstoffe konkurrieren.

Und die Frage ist jetzt,

wenn ich ein Antibiotikum dazu kippe, was passiert?

Kann ich natürlich wieder im Reagenzglas austesten.

Dauert dann genauso lange wie im echten Menschen.

Ist ein Problem.

Also ein Fernseher der Anwendung wäre zum Beispiel,

dass man eben eine Probe hat,

feststellt, welche Spezies sind da drin,

wie verhalten die sich und dann direkt simuliert,

welches Antibiotikum muss ich geben

oder in welchem Takt, mit welchen Bedingungen,

damit ich diese Handwerksinfektion

möglichst effektiv wegkriege.

Also das heißt, ihr könnt tatsächlich auch sowas, chemische Verbindungen

tatsächlich simulieren, da reinschießen und dann

sagen, hey, vielleicht kommt da was raus. Also wir simulieren

nicht die chemische Verbindung in dem Sinne,

sondern wir wissen halt, dass das

Antibiotikum hat die Auswirkungen auf das

Bakterium, ganz grob.

Aber auch das ist alles nur das

Fernsehen. Also wir sind eben, solche

Ökosysteme zum Beispiel zu simulieren ist

verdammt schwierig.

Hört sich sehr nützlich an. Also mal so.

Ja, deswegen versuchen wir es ja auch. Und deswegen gibt es

hoffentlich Leute, die uns dafür bezahlen, das zu machen.

Ja, und das ist so eine...

Hier wieder die große Sponsorenaufrufe.

Naja, aber ich meine, das klingt halt schon so ein bisschen

danach, wie man hat irgendwo einen umgekippten Weiher

und dann geht man da halt mit drei Gläsern

unterschiedliche Bakteriensocken hin, schüttet das da rein, wartet zwei Tage

und dann hat man eine Blümchenwiese da. Oder so, das wäre schon gut.

Ja, das wäre schon nicht schlecht.

Wenn man das ausfinden könnte, wie das geht.

Und das geht alles mit Python, das ist ja wie das

sollte, also mit der schönen Schlange und der Abenteuer.

Naja.

Also, und wie?

Genau, also

Also entweder sagt man, ich habe eine Simulation und Zeit stört mich nicht, also Laufzeit, das kann schon mal sehr häufig passieren, dann kann man es einfach wirklich rein in Python simulieren in vielen Fällen.

Ich habe auch Simulationswerkzeuge mal gebaut aus so Nebenkriegsschauplätzen, die wirklich rein in Python laufen und auch da einigermaßen effizient sind noch.

Ein Hauptproblem mit vielen komplexen Simulationen und jetzt mache ich jetzt wieder eine eigensinnige Überleitung zu dem, was ich wirklich gemacht habe.

ist, dass es

nicht so einfach und schnell

in Python geht und dass es insbesondere auch nicht

so schnell und einfach mit NumPy geht, weil es nicht

vektorisierbar ist. Jetzt muss ich wahrscheinlich kurz

erklären, was vektorisierbar heißt.

Das heißt, ich habe, ein klassisches

Beispiel ist, ich addiere zwei

Vektoren. Ich habe

ein großes Array mit Zahlen

oder Liste oder was auch immer man sich vorstellen möchte. Ich habe

eine andere, genauso lange Liste mit Zahlen.

Wenn ich jetzt sage, addiere bitte mal

die ersten beiden Elemente von jeder

Liste und füge das als erstes

neues Element in eine neue Liste und dann macht das

mit dem zweiten Element und so weiter und so fort,

dann ist das eine vektorisierbare Option,

Operation. Ich glaube, das hat

niemand verstanden, der nicht wusste, was vorher eine Vektor-Operation

ist. Verdammt.

Wenn du zwei Vektoren addierst, dann machst du

irgendwie sowas, du erklärst irgendwie

den Weg, den du per Luftlinie kennst

und dem erzählst du, ja, musst du links,

dann musst du rechts und dann kommst du irgendwann...

Das ist nicht so sehr das, was es tut, sondern die Art, wie es passiert.

Also es ist immer das Gleiche.

Also das auch gleich für viele Sachen

ist das so, Moment, jetzt muss ich es gerade

richtig hinkriegen.

Multiple Data,

Multiple Input, Single

Operation, Single

Operation, Multiple Data.

Also ich mache... Single Input,

7D, irgendwas. Genau, also

das Konzept ist auf jeden Fall

klar. Der Begriff ist nicht der

übliche wahrscheinlich, aber

alle, die es kennen, wissen, worum es geht.

Also ich habe einen Datensatz

und ich mache damit

5000 Mal das Gleiche.

wenn ich jetzt 5000 Elemente in meinem Datensatz habe.

Oder der Datensatz

wäre halt ein Array.

Das ist ein Problem, was in vielen, vielen

Simulationen auftaucht und das ist auch alles schön und gut.

Und das kann man

dann natürlich effizient mit solchen Sachen wie

NumPy gut lösen. Also nicht 100%

effizient, aber schon sehr nah dran.

Da ich dann eben,

wenn ich mit NumPy zwei Arrays addiere,

funktioniert es eben so, dass

der sagt, okay, ich erkenne, das ist jetzt eine Addition

und dann geht er jetzt nicht für jedes einzelne Element

dieses Arrays hin oder diese paarweisen

Arrays und

überlegt sich, oh, guck mal, was ist das

für ein Objekt? Ist das eine Zahl?

Aha, eine Zahl kann ich jetzt multiplizieren

mit einer Zahl. Was passiert denn da? Ah, da kommt wieder

eine Zahl raus. Und unter der Haube

findet dann die tatsächliche Multiplikation statt.

Das ist ja das, was im normalen Python passieren würde.

Sondern

der sagt, okay, ah, das ist ein Array.

Das ist aus Zahlen. Das ist noch ein Array aus Zahlen.

Und jetzt gehe ich mal

unter der Haube hin, lasse eine effiziente

Schleife da durchlaufen, die in C oder was

auch immer geschrieben ist, multipliziert die

alle elementweise miteinander oder addiert sie

elementweise miteinander und da kriege ich das Ergebnis.

Und das ist schnell. Und

wenn ich jetzt mein Problem ausschließlich

aus solchen Operationen beschreiben kann,

dann kann ich das auch

schnell mit NumPy und Python

lösen, ohne dass ich da irgendwie selbst

in C programmieren muss oder so.

Ja, ich glaube, also

ich weiß jetzt auch nicht, ob ich mich da ganz

komplett korrekt dran erinnere, aber ich meine,

ich glaube, der Witz bei dem Vektorisieren ist eigentlich, dass man

man hat ja mehrere Register irgendwie

und dann kann man das halt sozusagen in gewisser Weise

parallelisieren,

diese Addition oder Multiplikation von

Arrays, indem man das halt in

so viele Teile zeigt und das dann halt alles irgendwie gleichzeitig

macht. Oder diese Dinger sind irgendwie

oder man kann mehrere Dinger in einen Register packen.

Ja, das ist noch ein

Vorteil bei Grafikkarten und irgendwie könnte ich das dann

tatsächlich parallelisieren. Stimmt.

Also gerade dieses Rechnen auf

Grafikkarten, wenn man das immer, was man

immer wieder hört, das ist genau solche Sachen,

wo man eben mehrfach die gleiche Operation rechnet.

Aber das ist auch schon eine Sache,

die, wenn ich jetzt mit reinem Python arbeiten möchte

oder nicht irgendwas Neues programmieren möchte in Python,

mir mein Leben deutlich einfacher mache,

wenn ich sowas benutze wie NumPy.

Denn das Hauptkonzept von NumPy ist eigentlich,

wir haben vektorisierbare Operationen

und stellen sie dem Python-Nutzer zur Verfügung,

ohne dass der sich darüber kümmern muss.

Also wir stellen sie zur Verfügung,

wir stellen sie in effizienter Form zur Verfügung,

ohne dass der Nutzer sich darum kümmern muss,

da irgendwie in C, Fortran oder

was auch immer von niedrigeren Sprachen das

zu machen.

Ja, ich glaube

auch, ich habe mal gehört, dass das halt irgendwie der

Grund ist, warum Fortran immer noch so eine große Rolle

spielt, weil bei

Fortran diese Geschichten halt

die Schleifen, glaube ich, auch automatisch

vektorisierbar sind, bei C halt nicht. Und das ist halt

ein Problem, also man muss es dem Compiler halt sagen,

weil man da so Seiteneffekte

haben kann, dass das Ergebnis

der, eine Addition von

zum Beispiel zwei Vektoren kann halt wieder

irgendwie Einfluss nehmen auf was davor

und es ist halt

ja, sozusagen nicht garantiert,

dass man das halt

vektorisieren kann oder dass man es irgendwie parallelisieren kann,

sondern es kann halt an einem

die Programmlogik kaputt machen, wenn man das halt nicht

weiß, dass das geht und in Vortragen geht das

halt nur so und daher, aber ja, keine Ahnung.

Also mittlerweile stimmt das glaube ich nicht mehr,

oder nicht mittlerweile, ich glaube seit 15,

20 Jahren. Oh, das kann sein.

Gibt es in C das... Man kann dem

Compiler sagen. Restrict Keyword?

Ich hoffe, ich mache es jetzt richtig.

muss ich wahrscheinlich schämen, dass ich das nicht kenne, was eben genau

das sagt, okay, also das klassische Problem

ist ja, wenn ich

oder um das, was du vorhin beschrieben hast, nochmal

in anderen Worten zu beschreiben, dass

der Compiler nicht weiß, wenn ich

A und B addiere,

dass eventuell

das B, was ich da addiere, vorher

schon in einem vorigen Durchlauf

anders beschrieben wurde, an einem vorigen

Element der eigentlichen Schleife, also ich habe irgendwie

mein, nehmen wir wieder Vektoren,

es könnte sein, dass ich die erste Komponente zur ersten Komponente addiere

und dann kriege ich eine Komponente raus. Es könnte aber sein, dass ich das

in die zweite Komponente des Vektors

schreibe und das auch tatsächlich möchte, warum auch immer.

Wenn ich C programmieren möchte, ist das anscheinend.

Und

der Compiler geht davon aus, dass er das nicht weiß und

dass er sich das möchte und deswegen optimiert er es nicht weg.

Wenn ich jetzt aber sage,

dieses Array ist restricted oder

restrict, dann

passiert das nicht.

Also man kann das mittlerweile in C lösen.

Ja, genau, natürlich.

Aber das ist auch wieder eine Wissenschaft für

sich, wie man das dann genau

was man alles optimieren kann und wenn man es richtig schnell

haben will, dann muss man sowieso ein Assembly schreiben

und

immer mit GoTo-Schleifen immer hin und her springen.

Ja, aber

Assembly doch.

Nee, Assembly ist glaube ich noch schlimmer,

da gibt es keine GoTo-Schleife, da gibt es

Ja, da springst du zur Adresse oder sowas.

Genau.

Ja.

Also auf jeden Fall,

das ist ein,

Ja, also auf die Weise kann man dann Python in vielen Sachen

nutzen und jetzt

wieder gesagt, die schamlose Überleitung, nächster Versuch

zu meinen eigentlichen Sachen, die ich gemacht

habe.

Oder zu Sachen, die ich selbst gemacht habe, ist, dass

es in vielen solchen Simulationssachen

das Problem ist,

dass man es eben nicht vektorisierbar

machen kann. Also, was

in meiner vorigen Arbeit

sehr häufig aufgetaucht ist, ist zum Beispiel, dass

wir uns komplizierte Netzwerke von

man kann sich jetzt Neuronen vorstellen

angeguckt haben, die irgendwie miteinander

verknüpft sind und dann

hat man das Problem, dass die Verbindungen

zwischen diesen Knoten zufällig sind und dann

ab dem Punkt kann ich es nicht mehr sinnvoll vektorisieren.

Oder man kann sich

auch vorstellen, man hat komplexe

metabolische Modelle, wie irgendwelche

Spezies irgendwelche Stoffe in

andere Stoffe überführen und so weiter und das ist

eben auch komplex und

nicht vektorisierbar in vielen Fällen und das

muss man dann,

möchte man natürlich auch irgendwie effizient

haben und das Interessante ist, nebenbei

ist auch

viele Leute haben sich vorher immer

die vektorisierbaren Fälle angeguckt,

weil sie ja so schön einfach anzugucken

sind, weil man sie ja schön einfach

programmieren kann und viele

Phänomene zeigen sich eben erst, wenn es nicht vektorisierbar

ist oder wenn eben diese interessanten Fälle passieren

und da habe ich dann eine Software

geschrieben, die gerade das

für den Nutzer macht, dass man

irgendwelche komplizierten Gleichungen hinschreiben

kann, die das System beschreiben und die werden

dann für den Nutzer unter der Haube kompiliert,

nicht vektorisiert

und, oder nicht vektorisierbar und

trotzdem schnell in Python.

Ja, das

kam irgendwie...

Wo gibt es das zu finden? Oder ist das alles

private? Das gibt es zu finden,

das ist schöne, freie Software. Ich habe sie,

also es ist eigentlich drei

Software. Das erste ist JIT-Code,

das steht für Just-in-Time-Compilation

for Ordinary Differential Equations.

Also Ordinary Differential Equations

sind gewöhnliche Differenzialgleichungen. Just-in-Time-Compilation

sagt eventuell dem neigten Hörer was.

Das ist dieser Aspekt, dass

man irgendeine Eingabe

hat und die wird dann unter der Haube für den Nutzer

kompiliert. Und das

gibt es dann auch mal für sogenannte Delay-Differential

Equations und Stochastic-Differential

Equations, aber ich glaube, das ist

ein Detail, auf den wir jetzt nicht rumreiten müssen.

Ja, und

das ist ein Werkzeug, was dann

sich herausgestellt hat,

gut, ich habe es, als ich

das gemacht habe, konnte ich das natürlich schon irgendwo absehen,

dass das für viele Leute sehr nützlich ist.

Insbesondere, da wir uns damals

auch in der Forschung damit beschäftigt haben,

genau solche Probleme zu lösen.

Und

ja, eine Sache, die vielleicht auch noch

interessant ist, also man kann jetzt natürlich sagen,

der Nutzer gibt mir irgendwelche Gleichungen und die werden

umgesetzt. Das ist in Python

auch mit

SymPy, also das ist jetzt Symbolic Python,

das wird jetzt wahrscheinlich noch ein Exkurs,

eine schöne Möglichkeit gibt es, die Gleichung

einzugeben. Also SymPy macht

was denn? Also das ist jetzt wieder tatsächlich spannend, was

für die Heure, die das noch nie gehört haben?

Also normales Rechnen

im Computer macht man ja klassischerweise mit Zahlen.

Eins plus zwei

ist drei, genau. Aber

SymPy rechnet mit

Symbolen, also ganz abstrakten

Objekten wie X. Und das

Schöne an SymPy ist, dass es,

oder auch generell an symbolischen Rechnen, das hat jetzt

SymPy nicht erfunden,

aber das Schöne ist, dass es

dann exakt gewisse Sachen lösen kann.

Zum Beispiel, wenn man sagt X plus X,

steht da nicht X plus X, sondern

da steht da 2x. Oder wenn man sagt

x minus x, dann steht da

nicht 10 hoch minus 16 oder so,

sondern 0.

Und das ist dann auch exakt 0.

Und

ja, es hat sich herausgestellt, dass

diese Library gibt es und die hat auch direkt

Interfaces, um Sachen in

C-Code zu übersetzen, wenn man wirklich Sachen schnell

machen muss, was genau das ist, was ich brauchte.

Und sie

kann auch viele Sachen, die ihnen jetzt noch

für mich wichtig waren, automatisieren,

solche Ausdrücke analysieren, welche Symbole

tauchen da eigentlich auf. Damit

rechnen natürlich und eventuell sogar

Gleichungen lösen, wobei das eine Sache ist, die ich

interessanterweise kaum mache.

Auch wenn man sich irgendwie viele Leute vorstellt, dass das

wichtigste ist, wenn man so ein symbolisches Rechnen

hat, dass man tatsächlich...

Ja, genau. Man kann irgendwelche komplizierten

Gleichungen lösen. Ja, kann man.

Aber man kann es auch als Werkzeug nutzen, um

ganz stumpfe

Routineaufgaben durchzurechnen

und

es einfach als Eingabemaske zu nutzen

oder einfach

auch solche Ausdrücke zu analysieren und zu gucken,

okay, ja, welche Variablen tauchen denn eigentlich

auf? Also nichts, was ein Mensch nicht auch

könnte, aber eben automatisiert.

Kann man die auch, ich meine, wenn man das,

wenn es eine gute Methode gibt, die anzugeben, ich, das ist auch

vielleicht ein bisschen, kann man

dann auch irgendwie sowas sagen wie

printe mal das nett raus oder

latech dafür oder so,

das wäre natürlich auch, weil das

mache ich nämlich sonst immer total mühselig von Hand

und muss mir den Syntax zusammenklauben irgendwoher.

Nee, ich weiß nicht, ob ich sowas sagen würde,

der x plus x gleich x Quadrat

oder sowas, dass man

dann tatsächlich einen LaTeX-Direktor irgendwie kriegt?

Ja, der hat einen LaTeX-Printer.

Ich habe

damit noch nicht viel gearbeitet, insofern kann ich dazu nicht so viel

sagen. Also existiert definitiv.

Was man halt aufpassen muss, ist

die Frage, ob man das dann wirklich

so dem geneigten Leser

verkaufen möchte, wie es da ausgegeben wird.

Die Sachen sind halt so sortiert,

wie Sympa das gerade für richtig hält.

Also man kann das

wahrscheinlich modifizieren, aber dann

macht man sich mehr Arbeit, als es selbst zu schreiben.

Aber auch solche Sachen

gehen ja. Man kann es auch ausgeben, wenn man

unbedingt möchte.

Aber was natürlich so die Sachen sind, die in vielen

Anwendungen gar nicht auftauchen.

In dem Zusammenhang von diesem

Gleichung, da würde ich mich irgendwann mal über so ein Programm

beschauen, das heißt irgendwie LP-Solver oder so was?

Linear Programming oder so was?

Achso, ja, lineare Optimierung.

Da gibt es einige

Software zum...

Aber ich glaube, ich meine, da bin ich jetzt

wenig der Experte, ich glaube, das ist dann wieder ein Fall, wo es

numerisch gelöst wird, also mit Zahlen.

Das Interessante hier ist, dass wir wirklich mit

abstrakten Symbolen rechnen. Das ist ein bisschen was anderes.

Also natürlich, ja.

Okay, ja, vielleicht könnte man

das dann kombinieren oder sowas.

Ich weiß nicht, ich glaube, das Standardpaket

so für so konvexe Optimierung ist CVX-Opt

oder so, damit habe ich schon mal

ein bisschen was gemacht.

Es gibt dann noch so ein paar mehr Pakete, ja.

Also, aber ich glaube, das ist

nochmal eine andere

Richtung wahrscheinlich,

obwohl das auch wahrscheinlich alles in dem Scientific

Umfeld irgendwie so

existiert.

Es gibt sehr viele Standardprobleme mit sehr vielen Lösungen dafür

und schon allein die ganzen Probleme alle mit Namen

hinzuführen, da ist man dann eine ganze

Karriere mit beschäftigt.

Ich weiß nicht, ob das

bei dir noch eine Rolle spielt, aber ich habe da so mal früher,

da gab es irgendwie sowas wie Sage oder so,

das war so eine Distribution von ganz vielen Dingen.

Ob das das heute noch gibt? Ich habe keine Ahnung.

Es gibt es, glaube ich, noch. Ich habe auch damit gearbeitet.

Also, ja, also was ist

Sage? Ich kann sowas, also das ist,

es ist sehr komisch.

Es ist weitestgehend Python

und

ist speziell dafür gemacht, so ein Ersatz

für so Sachen wie, ja,

ich glaube, Mathematiker hauptsächlich.

Mathematik und so weiter zu sein. Es ist

ein großer Klotz, den man

sich kompilieren oder runterladen

muss. Der ist dann

600 Megabyte groß oder so

und funktioniert weitestgehend

wie Python, aber nicht

ganz. Also es gibt so

eigenwillige

Modifikationen, sage ich mal,

die dazu dienen, das ansprechender zu machen.

Ob das jetzt gut ist oder nicht,

sei dahingestellt. Also zum Beispiel ist

das, der Zirkum-Flex-Operator

Potenzierung macht, statt

Sternchen, Sternchen. Also Sternchen, Sternchen macht auch noch

Potenzierung, aber man kann es jetzt auch

mit... Okay, das wusste ich gar nicht, dass sie das geändert haben.

Also solche

Änderungen sind da drin. Es sind viele Sachen automatisch

geladen als Pakete.

Ähm, in so einem Standard-Namensraum, also es macht so ein paar Sachen, ja, wie soll ich sagen, komisch kaputt, die, nicht kaputt, aber so Sachen, die in Python eigentlich ganz gut sind, dass man den Standard-Namensraum eben nicht mit 10.000 Dingen vollgemüllt hat und die nicht einfach aus Versehen überschreiben kann und, ähm, weiß, wo die Dinge kommen, ähm, äh, wurden dann wieder zu nicht gemacht.

warum man jetzt den

Zirkum-Flex-Operator unbedingt brauchte,

dafür, ja, ob das so

wichtig ist, gut, ja.

Weiß ich nicht. Also ich habe damit

gearbeitet, es kann ein bisschen

mehr, oder konnte zu dem Zeitpunkt ein bisschen mehr als

simpel, andererseits eben

Sachen Gleichung lösen.

Was wie gesagt die Sache ist, die ich nicht mache, auch wenn

sie irgendwie alle warten, sondern ich nutze es wirklich eben

um Gleichung zu verarbeiten und damit

einfache Sachen zu machen. Deswegen habe ich das

letzten Endes nicht gebraucht.

Und es ist wie gesagt dieser

große monolithische Klotz, den man dann immer

auch komplett updaten muss oder wo man

ja, es war nicht sehr

handhabbar,

aber nicht schön, fand ich.

Aber noch ein kurzer Rückbezug, ist super zum

Code-Golfen, wie gesagt, alles wird in die,

viele Dinge sind im Standard-Namensraum,

das heißt, eine Lösung, ein Python-Programm

kompakter zu machen in Code-Golfen

ist dann, mach es in Sage.

Auch nicht schlecht, ja.

Ist natürlich keine Python-Lösung mehr, aber ja.

Ja,

Interessant. Also okay, aber SymPy scheint auf jeden Fall dann, wenn man irgendwie so Gleichungen symbolisch verarbeiten möchte, dann halt so das Mittel der Wahl zu sein. Was gibt es denn noch an Bibliotheken oder Software, die so regelmäßig benutzt werden und da eine wichtige Rolle spielen?

Also ich glaube, NumPy ist

klar, SciPy ist,

stellt einem

viele Simulations und Statistik

und sonst was Tools zur Verfügung.

Nutze ich zum Beispiel auch unter der Haube, um

gewöhnliche Differenzialgleichungen zu integrieren.

Für andere Differenzialgleichungen dann nicht mehr, weil das

komplizierter ist. Da habe ich dann meine eigenen

Integratoren implementiert.

Ja, dann, gut,

es gibt viele Sachen für Datenfahr,

also um wirklich

große Datenmengen und vor allem Daten zu verwalten,

Ich glaube, ihr hattet schon mal eine Folge zu Pandas, insofern werde ich davon nicht so viel erzählen. Kann ich auch gar nicht, weil ich es in der Regel nicht so viel mit Daten zu tun habe, aber die Daten, die ich habe, sind einigermaßen überschaubar.

Ja und dann eben ganz viele Bibliotheken, die gerade genau die Spezialanwendung machen, die man braucht und da ist eben das Schöne an Python, denke ich, dass es relativ einfach ist, erstmal irgendwas, wenn es nicht effizient sein soll, zu schreiben und zur Verfügung zu stellen, insbesondere auch Dinge zu nutzen und sie natürlich auch mit anderen Dingen zusammen zu nutzen, weil man am Ende eine vollwertige Programmiersprache dahinter hat.

Was immer das Problem mit anderen Sachen ist, die, also, ja, dass man eben irgendwann an die Grenzen stößt, dass man, gut, viele, häufig braucht man die Sachen natürlich auch nicht, häufig braucht man nicht, also, wenn ich jetzt, was weiß ich, Leute, die Matlab oder was auch immer nutzen, ja, die wollen damit natürlich auch keinen Webserver betreiben oder was auch immer.

ja, man kann halt auch

immer, also ich glaube, der Vorteil ist eher

nicht, also weniger, dass man solche

Sachen wie Web-Server oder so weiter nutzen kann, sondern

dass man sagen kann, das hier ist eine universelle

Programmiersprache, die lernen wir jetzt mal bitte alle

und dann können wir dann

machen, was wir wollen und wenn man allgemeine

Programmierkonzepte nutzt, kann man

sie verwenden, ob man jetzt, also muss jetzt gar nicht

in Python sein, aber wenn man

sowas wie objektorientiertes Programmieren einmal

verstanden hat, kann man das dann eben

für Simulationen nutzen oder oder oder.

Was ist so die häufigste andere Sprache, die du findest

in deinem wissenschaftlichen Umfeld, mit der du

dann auch arbeiten wollen würdest oder sagst,

das gehört auch dazu? Also arbeiten wollen würden,

das ist ja dahingestellt, ich musste

sage ich mal

einen Kurs

Datenanalyse in MATLAB für Biologen unterrichten.

Das heißt,

ja, das ist so die andere Programmiersprache, mit der

ich viel zu tun hatte. Ich habe es aber

geschafft, das weitestgehend

MATLAB nie anzurühren dazu für. Also es

gibt ja eine freie Alternative namens Octave,

das macht sich mal so für freundefreier Software etwas erträglicher aus,

dem musste ich mich da nicht irgendwie rumschlagen, das zu installieren.

Und ja, ich habe es tatsächlich weitestgehend geschafft,

diesen Kurs zu lehren, ohne das jemals anzurühren.

Und ja, also ich würde auch mit dieser Programmiersprache nicht arbeiten,

weil es gibt Sachen, das Schöne ist,

ich habe es irgendwie so dann zwei Monate vor dem Kurs mich hingesetzt

und das gelernt und wirklich jede Sache, wo ich denke,

okay, wer hat sich das ausgedacht,

das kann doch nur zu tausenden von Fehlern

und sonst was Problemen führen.

Wird da auch zu tausenden von Fehlern und Problemen los?

Ja, flog mir dann die Ohren, ja.

Es passt wirklich zum Teil, wie die Voraussetzung war.

Ich habe ja auch, ja gut, das kann man jetzt wieder nicht vorführen,

aber so ein Beispiel, wo man an einer Stelle,

ich hoffe, ich erzähle jetzt doch noch mal ein bisschen.

Matap hat die großartige Idee gehabt,

dass man das Leerzeichen als Elementtrennungsoperator

in Arrays nutzt.

Ja, ja, ja.

Nämlich, da war doch was.

Genau, also statt Kommata wie in Python.

Und man kann auch Kommata nutzen, man kann auch Semikola nutzen,

das ist dann eine neue Zeile, aber man kann auch Leerzeichen nutzen.

Und dann gibt es jetzt das Problem, wenn ich jetzt was tippe wie eckige Klammer auf,

was steht für Array?

Okay, soweit so erwartet.

Fünf Leerzeichen plus Leerzeichen drei, dann ist das natürlich acht.

Wenn ich aber eintippe fünf Leerzeichen plus kein Leerzeichen,

Achtung, drei, ist das natürlich das Array, was fünf und drei enthält.

war das Leerzeichen, ja, der

plus 3.

Und das Plus gehört dann halt zu der Zahl

und sagt einfach nur, das ist jetzt plus 5 und nicht minus.

Genau, ja. Und das

hört sich so noch

okay, kann man noch verstehen. Das Problem ist, wenn jetzt

die Arrays etwas größer und komplizierter werden und da komplizierte

Ausdrücke drinstehen, was manchmal tatsächlich der Fall ist,

dann kann einem

die Formatierung dieses Arrays dann die Probleme

machen. Also, ja.

Das war der Fehler, wo wir wirklich eine halbe Stunde gesucht haben,

um zu verstehen, was da überhaupt passiert.

Ja, das habe ich mir gut verstanden.

Man starrt da drauf und denkt sich so,

ja.

Und die Sprache ist halt jetzt voll davon.

Das wurde halt in den

80er Jahren entwickelt,

oder so 1987, 86, keine Ahnung.

Und seitdem gefühlt

nicht mehr weiterentwickelt.

Und ja, so bedient es sich auch.

Das erinnert mich so ein bisschen an Python, wenn du das Tupel

machen übergeben willst, dass du dahinter noch ein Komma machen willst,

weil da sonst kein Tupel macht, wenn du da einfach

ein Element nur drin hast.

Ja, genau, das ist noch so,

ja, aber das passiert halt andauernd.

Ja, und da gibt es

so zwischendrin gibt es R, das ist schon ein bisschen

besser.

Also erstens ist es frei, zweitens

ist es nicht ganz so irrsinnig,

es hält sich so ein bisschen an Programmierstandards,

aber

ja, damit habe ich noch nicht so

viel zu tun gehabt. Und es gibt natürlich auch diverse

andere Sparen. Das ist jetzt relativ

ein Kombis für Simulationen oder

Sachen, die schnell laufen müssen, ist Julia,

wo ich dann mich

immer noch frage, okay, wieso brauchen

wir jetzt hier noch klammern, weil

die Python ja zum Beispiel abgeschafft hat

und insbesondere, dass ich eine Sprache ist, die sich

in vielen Fällen, so wie ich es verstanden habe, an Python

orientiert. Ja, aber

sehr viel mache ich zur Zeit in Python und wenn es dann

schnell gehen muss, mache ich es eigentlich in C.

Also das sind so die Sprachen, mit denen ich

direkt zu tun habe.

Dann direkt tatsächlich als C-Extension

oder nimmst du sowas wie Cytan

und

wandelst das dann halt um

in C. Ich mache es tatsächlich

als C-Extension, weil ich es einmal gelernt habe und mich

auskenne. Zum einen und zum anderen

jetzt, um auf meine eigene Software zurückzukommen,

da ist ja wieder gerade das Problem,

dass ich es dann wirklich möglichst schnell haben möchte

und wenn ich den Nutzer dann

Siphon-Code eingeben lasse, habe ich

nicht so viel gewonnen.

Ja, klar. Dann kann ich auch direkt

C-Code machen und dann kann ich auch noch viele Sachen nutzen,

die eben so

in Siphon nicht drin sind.

Also doppelt verlinkte Listen

oder so, glaube ich, würden

Siphon nicht funktionieren.

Also, dann mache ich es schon

einmal Hardcore und kann

dann wenigstens die Sachen, die wirklich

schnell sein müssen, auch radikal

optimieren.

Du sitzt dann am liebsten mit der

Stoppuhr, timet und dann

guckst du dir das dann wirklich an?

Ja, also in einigen Fällen wirklich ja,

zum anderen bilde ich

mir ein, ein bisschen Erfahrung zu haben,

wie man Dinge schnell macht. Also

in vielen Fällen schreibe

ich die Dinge dann hoffentlich auch direkt so, dass sie schnell sind.

Also hintereinander direkt in den Speicher,

dass ein Zeiger nicht so schnell oder so viel hin- und herspringen

muss oder was es dann so ist. Ja, okay,

auf der Ebene bin ich noch nicht, aber dass man sich halt schon mal

überlegt,

ja, dass das könnte ich

jetzt,

dass man eben hier

diese gewisse Schleifen gar nicht braucht oder

ja,

mit Zeiger-Arithmetik arbeitet oder eben

sich überlegt, okay, jetzt habe ich hier noch einen Funktionsaufruf

und das kostet Zeit und

wie kann ich das

vermeiden oder wie kann ich hier die Suche,

also irgendwelche Suchoperationen, ja.

Okay, okay, das hört sich tatsächlich an, als wärt ihr tatsächlich

von der schwachen Hardware, die ihr noch zur Verfügung

stellt, in den Forschungsinstitutionen

so ein bisschen abhängig. Aber ich dachte, die wären eigentlich

schon weiter.

Abhängig von dieser Komplexität,

dieser unheimlich großen Berechnungen.

Naja, also die Hardware kann

ja nur so viel leisten.

Also erstmal, wenn ich ja durch die,

in vielen Fällen gehe ich, indem ich von

Python auf C gehe, hole ich

einen Faktor von 1000 oder so raus.

Bei mir.

Ja, da

will ich jetzt nicht mehr mit der...

Das klingt jetzt ziemlich viel.

Natürlich, also ich könnte das in Python

wahrscheinlich auch noch, wenn ich mich wirklich, wirklich stark

hinsetze, besser machen, dass es

nur noch ein Faktor 100 ist, aber

gerade solche Probleme habe ich eben.

Das muss man ja auch. Also

für viele andere Probleme gilt das übrigens nicht. Also ich habe

jetzt schon meine exotischen Spezialprobleme,

die ich und vielleicht noch

ein paar kleinere Communities auf der Welt

haben,

wo das wirklich einen riesen Unterschied macht

und wo ich dann eben auch Software geschrieben habe, die

diesen Unterschied dann wegmacht, aber

für Python-Nutzer rausholt.

Die...

So, jetzt war ich...

Was war nochmal deine Frage?

Ja, es geht so ein bisschen darum, also wie das dann hinterher

aussieht, also warum du diese Geschwindigkeit

dann über C rausholen musst, um das nicht

irgendwie, weiß nicht, andere Ideen dafür noch...

Großrechnung. Einfach mehr Hardware, ja.

Genau, mehr Hardware draufschmeißen. Genau.

Also natürlich kann man immer mehr Hardware draufschmeißen,

aber diese Hardware muss ja dann auch erstmal, also gerade wenn ich

einen Cluster habe, muss ich mich erstmal damit auseinandersetzen,

wie ich meine Sachen clusterfähig mache.

Und in vielen dieser Fälle ist es auch so, ich möchte das mal eben schnell laufen lassen, sofort das Ergebnis sehen und dann darauf basierend weiterdenken. Also ich habe viele Fälle, da habe ich eine Simulation, ich möchte jetzt verstehen, was passiert da, ich drehe an einem Parameter, ich möchte verstehen, was der Parameter macht und dann möchte ich sofort das Ergebnis sehen. Da hilft mir ein Großrechner nicht viel weiter, wenn ich das jetzt erstmal auf dem Großrechner lagen muss und so weiter und so fort.

Mhm.

Und dann irgendwann am Wochenende nachts gibt es dann mal Rechenzeit, wo man das dann durchläuft.

Das zweite Problem ist, ja, auch der Großrechner kann die Sachen nur hintereinander ausführen.

Viele Sachen, also gerade Simulationen, sind eben, ich habe ein großes System, ich simuliere das über die Zeit, es baut alles aufeinander auf.

Ich kann einfach nicht diese 500 Zeitschritte parallelisieren, denn die brauchen die ersten Ergebnisse vom vorigen Zeitschritt.

Also das heißt, da kann ich auch mit dem Großrechner unbedingt viel rausholen.

Was ich natürlich machen kann, ist, ich kann diese ganzen Simulationen, die ich habe,

sage, okay, ich möchte jetzt 500 Simulationen laufen lassen, die kann ich dann parallelisieren.

Aber da bin ich natürlich aufgerufen, wenn es schneller geht,

weil wenn es schneller geht, kann ich eben 500 Simulationen laufen lassen statt nur 5.

Und ja, das macht dann halt in vielen Fällen auch schon wieder einen schönen Unterschied.

Das klingt tatsächlich so, also wäre das ein großer Vorteil.

Also ich hätte jetzt nicht gedacht, dass man irgendwie das 100-fache da auch mit rausziehen kann,

weil ich hätte irgendwie gedacht, dass man die Sachen in Python

dann irgendwie mit Zeissen oder

was, dann irgendwie trotzdem so hinbiegt,

dass das bewerbsfähig ist.

Ich weiß nicht, wenn man sich jetzt hinsetzt

und das mit Zeissen hinbiegt, dann hat man eventuell

Faktor 10.

Das hängt so ein bisschen vom Problem ab.

Also ich habe wirklich Probleme, da habe ich,

also was ich gemacht habe, ist,

ich schreibe immer erst die Sache komplett in Python.

Wenn ich meine eigenen Sachen baue,

mache ich mir einen

Kern aus Python, von dem

ich weiß, was er tut, der lesbar und

so weiter ist. Und

wo ich erstmal lerne,

den Algorithmus so ein bisschen zu optimieren und

wie speichere ich Dinge und so weiter und so fort.

Und dann gehe ich hin und schreibe das Ganze

nochmal neu in C.

Was auch sehr schön ist, dann habe ich irgendwie eine Testmöglichkeit.

Ich habe einfach meine zwei Kerne, ich bombardiere

die mit zufälligen Eingaben und gucke,

ob sie das gleiche tun.

Aber von dem,

davor habe ich halt dann auch einen guten Vergleich.

Weil ich habe das einmal in Python

geschrieben, genau dasselbe.

Vielleicht dann, ehrlicher gesagt, auch nicht

optimiert darauf, dass es besonders schnell ist,

sondern eben auch, dass es lesbar ist und vergleichbar und dass ich

verstehe, was es tut und dass es gut testbar

ist und so weiter und so fort.

Das muss ich dann schon eingestehen, aber es ist

trotzdem, je nach Aufgabenstellung wirklich,

sind es solche großen Faktoren.

Mit Cypher, ja,

wenn ich das jetzt in Cypher programmieren könnte

oder wollte oder meinen Nutzer

das vermuten würde,

dass er das in Cypher programmiert,

ja, okay, dann

wäre es vielleicht nur noch ein Faktor, keine Ahnung,

10, 5, was auch immer,

Aber dann geht natürlich auch sehr viel Programmierzeit

drauf.

Wenn du jetzt sagst, so deine Nutzer, das heißt, du

stellst tatsächlich so ein Programmierinterface bereit

und deine Nutzer machen ihre

Dateneingabe oder die Schnittstelle

dafür noch komplett selber?

Also meine Nutzer sind Programmierer.

Das muss ich auch immer unterscheiden. Das ist immer sehr

lustig, wenn man dann auf diesem Python-Treffen

sitzt mit allen möglichen Leuten

und die aus dem Web-Bereich und so weiter

kommen und erstmal deren Nutzer natürlich keine

Programmierer sind und sich dann

Gedanken und man ganz andere Vorstellungen

wie man eine Fehlermeldung schmeißt.

Meinen Benutzer schmeiße ich einfach eine Fehlermeldung

und die können die dann hoffentlich auch lesen.

Naja, manchmal.

Also meine Nutzer sind Programmierer

und die brauchen jetzt kein grafisches Interface zum Glück.

Du visualisierst dann auch gar nichts von den Lösungen irgendwie,

sondern das schmeißt du dann irgendwo rein

und dann kann man...

Ja, das kann der Nutzer dann mit einem Plotprogramm machen.

Das ist der Plotprogramm der Wahl oder was auch immer.

Gut, meistens ist da Matplotlib.

Aber das ist ja in modularer Denkweise nicht meine Verantwortung, da irgendwas zu visualisieren, sondern mir geht es nur darum, die Lösung zu produzieren an der Stelle.

Also tatsächlich Python und C dann parallel und dann hast du dann eine schnelle und eine hübsche und effektive Lösung, deine Probleme so zu behandeln.

Und würdest du sagen, das, was du da machst, das hast du jetzt gesagt, das ist irgendwie sehr speziell auf so einer Insel, das kannst du auch übertragen oder könnte man übertragen auf andere Wissenschaften und andere Anwendungsfälle so ohne weiteres?

oder ist das gar nicht möglich?

Ja, also so klein ist die Insel nicht.

Das Problem, gewöhnliche Differenzialgleichung

oder retardierte Differenzialgleichung

und so weiter und so fort zu lösen,

das betrifft schon eine gewisse Menge,

also schon nicht wenig Leute.

Also ich könnte jetzt,

es tut mir schwer, eine Zahl abzuschätzen,

wie viele Wissenschaftler und andere Leute

sich mit so einem Problem beschäftigen.

Wir stinken halt nicht an gegen die Leute,

die partielle Differenzialgleichung haben.

Das sind diese klassischen vektorisierbaren Fälle,

Was man so sieht, wenn Leute Wärmeleitungen

simulieren oder irgendwie

physikalische Verformung und solche Sachen.

Die machen alle Parzelle von Zahlgleichen.

Ja, also

die Insel ist nicht so klein,

aber sie ist, ja,

kleiner als vielleicht andere größere Inseln.

Was jetzt wahrscheinlich keine

sinnvolle Aussage ist.

Ja, also ich meine, gut,

ich kenne jetzt vor allen Dingen halt

den ganzen

Data-Science-Bereich, da auch das

das wissenschaftliche Umfeld. Da gibt es halt

Differenzialgleichungen hat man da eigentlich nie so wirklich

zu tun, auch nicht mit symbolischen. Da wird immer eher so,

da packt man die große

GPU aus und dann sucht man damit das

Problem halt zu. Nee, aber das ist ja auch ein ganz anderer Ansatz.

Ich habe Daten und ich will

sie verstehen. Bei Simulationen geht es darum,

ich habe eine Idee,

wie Sachen funktionieren. Ich möchte jetzt mal gucken, was eigentlich

passiert, wenn ich diese Idee in die Tat umsetze.

Ganz doof gesagt. Ich habe mein Modell und