Transkript: Python in der Visual Effects Branche

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

Herzlich willkommen beim Python Podcast.

Heute ist die 31.

Episode.

Wir machen heute Visual Effects und Python, also ein bisschen aus der Filmindustrie.

Und wir haben natürlich neben dem Jochen, hallo Jochen, und mir, den Dominik, einen wunderbaren Gast dabei, den Fabian.

Und ich finde, er kann sich selber vorstellen, er macht nämlich tolle Sachen und du musst erstmal erklären, was ist dein Job und wer bist du und was machst du denn?

Ja, hallo, also ich bin Fabian, ich arbeite als Pipeline-Developer oder Pipeline-TD in der Visual Effects Branche.

Und genau, ich programmiere quasi Arbeitsabläufe im Hintergrund, weil die Datenmengen und das, was da passiert auf dem Bildschirm, da muss halt eine ganze Menge im Hintergrund auch geregelt werden.

Also alles in Python?

Größtenteils schon.

Und das, was du da machst, ist irgendwie, man guckt einen Film und dann explodiert irgendwas und die Art und Weise, wie das explodiert, das baust du, oder?

Das macht quasi der Art, der hat ein spezielles Programm, das das kann.

Ich bin aber quasi noch eine Stufe davor.

Ich regel quasi, dass diese Artist sich nicht mehr darum kümmern muss, wo er Sachen abspeichern muss, sondern quasi einfach nur sagen muss, okay, ich möchte an Haus XY arbeiten und das in die Luft jagen, mach mir mal eine Datei auf.

Und das ist quasi mein Job, den ich da im Hintergrund mache, dass die das alles nicht mehr nachdenken müssen, wo sie Sachen abspeichern, wo sie Dateien hinkommen.

Und diese ganze Geschichte in der Filmindustrie, die kann man tatsächlich also auch mit Python machen.

Und darüber werden wir heute euch ein bisschen erzählen.

Schön, dass du da bist, Fabian.

Vielleicht fangen wir nochmal bitte ein bisschen Struktur an, ihr wisst, wir vermissen das immer ein bisschen selber.

Es gibt ein bisschen News, glaube ich.

Ja, was haben wir denn also?

Wir haben viele Neuigkeiten.

Aber also ein Ding, was mich so ein bisschen freut, oder ach nee, das nehme ich mir auf.

Das nehme ich mir auf für was anderes.

Für die Fix später.

Genau.

Nee, komm, jetzt musst du spoilern, weil Gebäude hören.

Das hat was mit der Fischstelle zu tun.

Das reicht.

Mit was hat das zu tun?

Mit der Fischstelle, die kennst du auch.

Oh, ja, natürlich kann ich die lustig decken.

Ja, und ansonsten ist halt noch irgendwie Django 3.2 ist released worden.

Oh ja.

Hast du ja schon alle in Produktionen?

Also es ist relativ einfach gegen der Umstieg ohne Probleme.

Ja, also bei mir war, das war mittlerweile, ich glaube, das war echt das problemloseste Django-Upgrade, das ich bisher so hatte.

Man kann sich jetzt ein neues Setting gewöhnen, die da die Standard Key oder Primary-Key-Variante ist, die man kenne für seine ganzen Projekte hätte.

Ja, das muss man jetzt halt konfigurieren sozusagen.

Genau.

Sonst kriegt man Warnungen.

Genau, aber es gibt nur eine Warnung, das war alles und dann funktioniert alles wie vorher auch.

Und er nimmt sogar die alten Keys und behält die.

Er macht die also nicht weg und nimmt also nur die neuen Tabellen, die man einbaut.

Also es passiert nichts Schlimmes, wenn man jetzt irgendwie upgradet, nicht, dass dann plötzlich alle Primary Keys doppelt so groß sind.

Wir sind mittlerweile bei 3,9, weiß ich nicht, vier oder so und ich warte immer noch auf 3.10.

Ihr wisst warum.

Ihr kommt ja jetzt demnächst auch bald.

Ja, genau.

Ich hätte auch noch ein paar News.

Einfach mal aus meiner Branche.

Autodesk Maya ist jetzt auf Version 2022 hochgestuft worden.

Das Besondere daran ist, wir sind endlich auf Python 3.

Oh.

Oh wow.

Ja.

Blast from the Past.

Ihr hört also, die Vision Reflex-Industrie ist anscheinend sehr weit vorne, was Software angeht.

Woran das wohl liegt, also ich habe gehört, viele arbeiten dort tatsächlich mit Windows und die Interpreter sind alle eingebaut in die Programme.

Ja, die sind in fast durchgängig allen Programmen eingebaut, was natürlich das Upgraden zwischen den Python-Versionen relativ schwierig macht, weil, naja, die Programme sind eher konservativ eingestellt und sagen, okay, bevor wir den Artist da ihre Skripte kaputt machen, fassen wir das mal lieber nicht an.

Und naja, zwölf Jahre später wird es jetzt so langsam auch security-technisch und so kritisch, dass man Python 2 eigentlich nicht mehr so richtig benutzen sollte.

Und ja, jetzt ziehen wir langsam nach.

Ich würde sagen, gut drei Viertel aller Programme, die so gängig sind in der Industrie, haben es inzwischen einigermaßen geschafft auf den Sprung, aber es gibt immer noch so ein paar Nachzügler.

Vielleicht für alle ganz unbedeckt und was ist denn Maya?

Maya ist ein sehr geläufiges 3D-Programm aus der Branche.

Also Admir heißt, man kann Modelle, Objekte rendern, generieren, darstellen, bauen.

Genau.

All das im Grunde genommen.

Sprich, du willst einen Charakter oder ein Haus irgendwo in eine Szene stellen, dann kannst du es da bauen, hübsch ausrendern und ja, auch durchprogrammieren mit Python, wenn du möchtest.

Das heißt, ich kann dann Achsen skalieren, drehen und Bewegungsabläufe skripten oder was macht man da mit Python?

Genau, die Python-API in Maya ist eigentlich sehr, sehr mächtig.

Du kannst im Grunde genommen wirklich alles durchskripten, wenn du möchtest.

Alles, was du per Keyboard und Maus eingeben kannst, kannst du genauso gut in Python einscripten.

Also wenn du wild genug bist, kannst du wirklich ein Python-Programm schreiben von A bis Z und am Ende hast du einen Baum.

Kein Problem.

Ach, nett.

Also da hätte man verschiedene Objekte und könnte dann eine kleine Bibliothek bauen mit verschiedenen Bäumen, hat man den ganzen Wald und dann in den Wald, haben muss man natürlich noch verschlossen und dann auch in den Spald mit dem Drachen und nach dem Prozess.

Okay.

Ja, aber schick, weißt du, warum, warum, aber eigentlich sind wir da schon fast im Thema, ne?

Wir können eigentlich auch können wir auch einfach das kannst du wahrscheinlich ja sagen, woran das liegt.

Warum hat man sich denn da so auf Python quasi standardisiert?

Weil ich kenne das jetzt aus anderen Bereichen, da es wird häufig zum, damit man halt irgendwie so Applikationen skripten kann.

Also ich kann das zum Beispiel hier von der von der digitalen Digital Audio Workstation, die ich hier verwende, das ist Reaper.

Da ist das Lua oder halt auch von diversen anderen, so Money, Money, also Online-Banking ist auch Lua, also ganz oft ist es Lua, weil man das halt super einfach integrieren kann in C.

Aber Python ist eigentlich gar nicht so super einfach zu integrieren.

Warum wird da Python genommen?

Ich glaube, es ist auch so ein bisschen historisch bedingt.

Die ersten Programme und Anbindungen haben einfach mit Python angefangen und nach und nach hat sich das quasi etabliert.

Es gibt auch genug Beispiele von, also Lua gibt es zum Teil, habe ich auch schon gesehen.

Aber viele Programme, unter anderem Maya, haben zum Beispiel auch einfach ihre Skriptsprache selbst erfunden.

In Maya gibt es Mail, die Maya Embedded Language.

Erinnert sehr stark an Bash.

Oh.

Okay.

Also wer Bash mag, hat da wahrscheinlich seine helle Freude dran.

Und das Schöne an Python ist aber, dass man sehr gut eigentlich dynamisch Sachen rappen kann mit Python.

Im Grunde genommen in Maya ist Python nichts anderes als ein großer Rapper um Mail.

Sprich.

Ah, okay, das heißt, du sprichst eigentlich direkt per Kommandozeile mit den verschiedenen Endpunkten dieses Programms und

Kommandozeile ist hier übertrieben.

Also du befindest dich im Programm selbst, aber Mail ist Bash ähnlich, ja.

Also du arbeitest aber jetzt nicht auf der Kommandozeile.

Das heißt, die API, das Interface des Programms, das irgendwie so, dass es halt Befehle entgegennimmt.

Genau.

Die man dann aber nicht eingeben möchte, sondern die man automatisiert über Python-Skripte.

Das ist halt, also ich stelle mir das so vor, Menschen, die ganz viel so 3D-Sachen machen, die programmieren L-lange Skripte, ganz viel Code untereinander, um Dinge zu automatisieren und schöne Figuren zu rennen oder Bäume, wo wir diese Wellen, wo wir eben drüber gesprochen hatten.

Entspricht das der Realität oder wie sieht denn dein Arbeitstag dann damit aus?

Das Artists an sich, die machen da eigentlich alle Arbeit nur über das User-Interface.

Relativ wenige Skripten.

Es gibt ein paar spezielle Jobs da, wo man muss mal ein bisschen mehr Skripten, weil es dann schon aufwendiger wird.

Aber mein Arbeitsablauf ist eigentlich eher im Hintergrund.

Sprich, ich überlege mir, okay, an meinem Projekt arbeiten 40 Leute, die alle auf den gleichen Folder zugreifen auf meinem Server.

Wie kriege ich es denn gebacken, dass die sich nicht gegenseitig in die Quere kommen oder sich Files überschreiten schreiben oder Sachen verloren gehen?

Also auf so einem Videoprojekt, da müssen ja ganz schön viele Daten auf so einem Server liegen, oder?

Genau.

Genau, um so ein paar Eckdaten zu haben, also für ein Projekt, was wir neulich selbst abgeschlossen haben, was ihr auch auf Netflix gucken könnt übrigens, nennt sich Outside the Wire.

Ist wirklich, also Visual Effects Top.

Story, naja.

Aber da hatten wir im Endeffekt 12 Millionen Dateien auf dem Server und das waren insgesamt 220 Terabyte, glaube ich.

Und naja, das ist halt eine Menge Holz.

Ein bisschen größer als mein Heimcomputer.

Das will man erstmal durchs Netzwerk schleifen und dann natürlich auch noch die Übersicht behalten, dass du weißt, okay, ja, diese Version fand ich schön, die nächste ist vielleicht nicht so toll.

Ja, dann muss man auch noch bedenken, okay, diese Artists, die arbeiten natürlich auch noch miteinander.

Also der eine baut das Haus, der andere mal es an, der nächste lässt es explodieren.

Dann musst du natürlich auch noch zusehen, okay, wie bekommst du denn die Daten von A nach B, dass jetzt nicht jeder erstmal Windows Explorer aufmacht, ein Tipp, okay, wo ist denn mein Haus und wo finde ich denn das?

Sondern auch das ist alles durchgeskriptet und gestreamlined.

Dass du einfach nur sagst, okay, ich möchte von Haus, von meinem Haus, ja, diese Außenwand in Version 6.

Zack, reingeladen, fertig.

Also, okay.

Guckt man da irgendwie über so einen Editor drauf oder sowas?

Oder ist da dann ein Maya-Interface oder habe ich so eine Sicht wie so ein CAD-Programm, auf das ich dann schauen kann?

Oder ist das so ein Studio-Umgebungsding?

Das ist alles integriert.

Neben Python hat sich noch ein anderer Standard relativ gut in der Branche etabliert und das ist PySite bzw.

PyQt.

Sprich, viele Programme unterstützen das, dass man mit dieser Bildbibliothek quasi arbeiten kann.

Und das Schöne an der Sache ist, man kann somit auch User Interfaces komplett durchscripten.

Sprich, du kannst direkt sagen, okay, ich habe jetzt hier mein Datei lauder, wie auch immer, programmiere das User-Interface dafür einmal durch und wenn ich den aufrufe in Maya oder in The Foundry Nuke, sieht er halt gleich aus, führt die gleichen Zwecke.

Und da nur im Hintergrund arbeitet man halt vielleicht an verschiedenen Code-Stücken, weil eine Datei zu laden in Maya ist was anderes als in Nuke.

Also auch wir benutzen quasi relativ gängige Bibliotheken.

Vielleicht musst du uns da nochmal so ein bisschen einführen und so ein bisschen diese ganze Infrastruktur und das ganze Ökosystem so näherbringen, dass wir so ein bisschen diese Bausteine, die es da gibt, zusammensetzen können, weil wenn ich jetzt dazu höhere, ich habe ja keine Ahnung von diesem Videothema, dann verstehe ich jetzt noch nicht genau, wie du diese einzelnen Bälle logierst und wie das funktioniert.

Okay, fangen, wie fangen wir da am besten an?

Vielleicht so ein paar allgemeine Sachen.

Sprich, dadurch, dass ja die Interpreter in den einzelnen Programmen eingebettet sind, muss man oder sollte man zumindest danach streben, dass man alles relativ gut gestreamlined hatte mit verschiedenen Bibliotheken, die man auch in verschiedenen Sachen laden kann.

Das heißt, du kannst in jeder einzelnen Interpreterschicht dieselbe Interface nutzen, oder was meinst du mit Streamline?

Genau, zum Beispiel.

Man will ja quasi nicht fünfmal das gleiche skripten, obwohl du das gleiche willst, sondern sagst, okay, ich baue mir ein User Interface in PySight, bau das aber so, dass ich es wiederverwenden kann in anderen Programmen auch.

Dann geht es quasi nur noch darum, dass du die Business Logic im Hintergrund austauschst, dass du die Funktionalität für den Anwender aber überall gleich ist.

Hat auch den Vorteil für jemanden, der die Programme benutzt, der hat immer das gleiche User-Erlebnis.

Sprich, ob du einen Pfeil lädst oder einen Pfeil öffnest, ist eigentlich ganz egal, ob du jetzt ein 3D- oder ein 2-Drehprogramm aufmachst.

Ja, also diese ganze Hierarchie, wie das alles aufgebaut ist mit den Bibliotheken, ist natürlich wahnsinnig komplex.

Aber was für Jobs gibt es denn in dem Bereich?

Also wenn ich mich da in der Industrie wiederfinden möchte, welche Jobs gibt es denn die Python machen?

Da es so offen ist, kann es im Grunde noch jeder benutzen, der möchte.

Weshalb auch eine Menge Code quasi am Markt ist, der weniger gut ist, hätte man so gesagt.

Aber es gibt zum Beispiel den Job des Riggers.

Oh, ein Rigger, dass das in Shadow Punk, ist das ein Mensch, der seine Drohnen nach oben schickt und die steigen lässt.

Genau.

Das ist jemand, der quasi virtuelle Marionetten in Charaktere baut.

Ah, okay.

Also von innen werden quasi diese Dinge bewegt.

Genau, weil wenn du einen Charakter modulierst, dann steht er zwar erstmal schön im Raum, aber dass er zum Beispiel seine Knie beugen kann oder seine Arme beugen kann, das muss man dem Rechnern ja erstmal verklickern, weil für den ist das nur ein Datenhaufen.

Da muss man ja erstmal sagen, okay, das ist die Hand, das sind die Finger, die lässt sich so und so bewegen.

Und damit am Ende auch eine schöne Animation, also ein Animator dann das animieren kann, muss das natürlich erstmal gebaut werden.

Da das ein relativ technischer Job ist, ist da sehr viel mit Scripting eigentlich nur zu machen.

Weil so eine Marionette aufzubauen, dauert einfach ewig lange.

Ja, du musst ja die ganzen einzelnen Gelenke wahrscheinlich machen.

Marionette bedeutet, dass halt so die Dinge miteinander verbunden werden.

Das heißt, wenn man jetzt irgendwo den Arm hochzieht, dass dann andere Dinge mit hochgezogen werden oder so, sozusagen.

Ah, okay.

Genau.

Oder zum Beispiel, dass du Muskeln hast.

Du beugst den Arm, dann geht dein Bizeps eben raus.

Ah, ja, nein.

In der Körperstatur kann man sich nicht richtig bücken, weil dann muss der ganze Körper.

Ja, verstehe.

Genau.

Da hängt eine Menge dran.

Dann auch so Kleidung ist auch nochmal ein eigenes Thema für sich.

Haare ist auch noch ein eigenes Thema für sich.

Also sehr große Studios wie Pixar zum Beispiel haben wirklich nur Leute, die beschäftigen sich 24-7 nur mit Haaren.

Tja.

Oder nur mit Kleidung.

Also klingt aber relativ spannend.

Also das kann man für coole Sachen benutzen.

Das klingt so, als wenn man einmal diese Logik und als Modell und als Skript irgendwie komplettieren würde, dann könnte man auch die ganzen externen Effekte, also sowas wie Wind und Licht und was sich da alles gibt, als Umwelteinflüsse dann auf dieses Rig oder so übertragen, dass man halt so ein bisschen, ja, also nicht so statisch im Raum rumsteht und vielleicht ein oder zwei geskriptete Bewegungen macht, sondern tatsächlich mit der Bewegung interagiert oder in die Umwegung so eingebettet wird.

Also sozusagen, ja, ja, ja.

Das heißt, der Job von dem ist sozusagen vorzubestimmen, was sich alles noch mitändert, wenn sich irgendwas, wenn irgendwas bewegt wird und der Animator, der gibt dann quasi vor, wie die Bewegung aussehen

soll und wie weich das wird, die Bewegung innerhalb der Umgebung.

Aber der kümmert sich dann nicht mehr darum, dass sich quasi, keine Ahnung, die Kleidung mitbewegt, wenn sich der Arm bewegt oder so.

Genau, der fängt nur die eigentliche Bewegung ein und das, was dann darum passiert in der Umgebung, das müsste dann mit durch die Skripte passieren, oder?

Weil das ist ja fast Physik.

Also das ist ja das, was man durch Algorithmen irgendwie vielleicht macht.

Also das ist eigentlich noch mehrstufig.

Im Grunde genommen hast du erst das Rig, dann hast du den Animator, der da eine Animation drauf macht.

Da ist aber meistens noch relativ wenig Physik dabei.

Und erst im nächsten Schritt gibt es dann quasi Simulationsschritte, wo du dann sagen kannst, okay, über meine Animation habe ich dann nochmal ein bisschen Wind, die dir dann die Klamotten noch wehen lässt oder die Haare oder keine Ahnung, Feuerexplosionen, was immer du willst, dass der Arm abfällt, geht alles.

Genau, weil gerade Physiksimulationen sind wahnsinnig ressourcenfressend.

Das heißt, du kannst wenig interaktiv arbeiten als Animator, wenn du die ganze Zeit dann auf Physiksimulationen arbeiten im Hintergrund laufen hast.

Also das tatsächlich aus technischer Restriktionen noch, oder?

Ja, durchaus, ja.

Es ist immer noch eine hohe Kunst, performante Rigs zu bauen.

Weil die Animatoren, die wollen natürlich immer Echtzeit haben.

Also 24 Frames die Sekunde sollte schon sein.

Aber dadurch, dass die Programme halt so komplex sind, ist es unheimlich einfach, sehr langsame Rigs zu bauen.

Und wenn du dann, ich meine, du musst, weiß man ja selbst, man sitzt vor einem Rechner und wenn irgendwas so im Sekundentakt vor sich hin ruckelt, ist das irgendwie kein schönes Arbeiten.

Aber wenn es flüssig ist und man sich das angucken kann im Ganzen, dann hat man halt am Ende auch mehr Spaß.

Ich meine, ja.

Ja, klar.

So es gibt hundert tolle Wege, wie man das verschnellern kann und verbessern kann.

Und die Industrie ist natürlich auch immer vorne mit dabei, da die neuesten Technologien einzubauen.

Ja, aber wir schleppen halt auch eine Menge Legacy-Stuff mit uns rum, wo viele Leute sich sehr lange dran gewöhnt haben.

Und es ist auch schwierig, das loszuwerden.

Ja, ja, nee, ich meine, aber ich kann mir auch vorstellen, dass es einfach an den Release-Zyklen hängt.

Ich habe jetzt keine Ahnung, wie oft, weiß ich jetzt nicht, irgendwie Maya oder Houdini oder was auch immer da released wird oder eine neue Release hat, aber wenn die relativ lang sind, dann ist ja klar, dass die nicht so aktuell sein können wie andere Software, die man jetzt, weiß ich nicht, irgendwelche Web-Applikationen, die man ständig deployt.

Ja.

Wobei man sagen muss, Houdini ist eine sehr tolle Ausnahme, die bieten Nightly-Builds an.

Was ist denn Houdini?

Houdini ist eine der größten Effektssoftwaren, die man im Moment so haben kann.

Sprich, damit machst du Feuer des Häuser zusammenfallen.

Es ist unheimlich modular und dadurch auch wahnsinnig komplex zu bedienen.

Also ich kenne einige Leute, die an der Einstiegshürde einfach gescheitert sind.

Die also gefühlt musste dich erstmal ein Jahr einarbeiten.

Aber wenn das ganz ein bisschen an Magier, also ein Houdini, der dann tatsächlich die höhere Effektschiene hat, okay.

Aber auch da ist Skripten wieder total angesagt.

Die haben sogar interne Skripte, die sich, glaube ich, sogar zu C kompilieren, so halb, damit das dann richtig fix wird.

Genau.

Haben aber auch wieder ihre eigene Skriptsprache darüber funden.

Also es gibt ja quasi ein Level-Interface, was da drüber liegt.

Also eine API, mit der man Houdini-Methoden wie Tun ausführen kann.

Ist auch recht interessant interessant, weil gerade das Python, dadurch, dass Python so modular ist und auch so sich so in verschiedensten Arten umform lässt, benutzt jeder jedes Programm Python auch in verschiedenen Arten und Weisen.

Also Pythonic würde ich sagen, ist da eigentlich nichts.

Also das ist alles schon ein sehr gewagtes Zeug, was man da macht zum Teil.

Deswegen gibt es sogar schon Rapper-Libraries, die das alles mehr in die Pythonic-Richtung drücken, weil irgendwann die Skripter sich halt auch gesagt haben, so, ey, so funktioniert das nicht.

Ja, aber das ist also auch das, was man so auf der generellen Python-Welt hat, oder?

Dass halt je mehr Leute sich das zur Brust nehmen und damit arbeiten, umso schneller entdeckt irgendjemand das wirklich tolle Higher-Level-Interface.

Und man kann halt irgendwie mit einer einfacheren API die gleichen oder schönere Dinge machen.

Ja.

Ich hatte neulich so ein schönes Beispiel.

Ich hatte eine Funktion namens getStringParameter oder irgendwas und der hat mir eine Liste zurückgegeben.

Super.

Vielleicht hätte ich mir eine Type-Annotation geschrieben und dann war es mir da, dass es eine Liste zurückgibt.

Halt er mal eine Liste zurück und das macht dann halt irgendwie keinen Spaß zu lesen.

Ja, ja.

Ja, ne, witzig.

Also Datentypen und so, was das reinnahme ist.

Ja, was wollte ich eigentlich?

Ich wollte irgendwas fragen.

Jetzt habe ich vergessen, was ich fragen wollte.

Ist das denn nur für jetzt, also ich meine, diese ganzen, also Maya und also Houdini ist doch eher so auch Realfilmgeschichte, also quasi, wenn man irgendwie tatsächlich gefilmtes Material hat und da einen Effekt machen möchte.

Oder ich habe ehrlich gesagt keine Ahnung, wie das alles zusammenhängt.

Also für mich klingt das auch alles so, als könnte man total die tollen Computerspiele damit machen.

Es geht eigentlich in alle Richtungen, die du möchtest.

Du kannst damit abstrakt bleiben, du kannst es in Realfilm einbetten, du kannst auch Full CG-Sachen machen, aller Toy Story.

Ist kein Problem.

Du musst halt nur wissen, wie du es anfasst.

Eine große Rolle dabei spielt auch immer der Renderer.

Sprich, das Programm, was dir am Ende die schönen Bilder auf die Leinwand zaubert.

Wir benutzen zum Beispiel in der Produktion Arnold.

Der ist schon sehr auf Realismus ausgelegt, was auch für unsere Firma einfach Sinn macht, weil wir benutzen halt sehr viel Echtzeit, also Real Footage, wo wir Sachen einbauen möchten.

Aber man kann auch sehr viel offener gehen.

Ich glaube, Renderman zum Beispiel macht das alle, kann man noch sehr viel mehr mit einstellen.

Hat natürlich auch alles immer seinen Preis.

Also je offener du bist, desto langsamer wirst du im Endeffekt.

Meistens.

Und dadurch, dass man, wenn man sich quasi vorschreibt, okay, ich möchte so realistisch und physisch akkurat bleiben, wie es nur irgendwie geht, dann heißt das auch, okay, ich kann halt Performance an gewissen Stellen halt einfach einbauen, weil ich weiß, okay, ich werde niemals so einen Cartoon-Charakter-Look brauchen.

Kann man weglassen.

Also kannst du vielleicht nochmal kurz erläutern, was du mit Performance meinst.

Also jetzt die Geschwindigkeit, die das Ganze zum Rendern braucht.

Aber ich denke mir jetzt gerade, du hast ja eh vorgefertigte Szenen.

Also du wirst das ja jetzt nicht live irgendwie augmentieren, sondern du möchtest ja quasi einen Videoschnipsel, den du irgendwo liegen hast, ergänzen und da filtern oder Sachen drauf spiegeln oder also neue Dinge erschaffen mit einem Schnipsel, den du schon hast.

Und da ist auch quasi die Zeit, die das braucht, um zu rendern und Dinge dazu zu erfinden, relativ dehnbar.

Ja, aber die Ressourcen sind ja nicht endlos dehnbar.

Sprich, wir haben zum Beispiel so eine Faustregel, dass für uns ein Frame nicht länger als eine Stunde rendern sollte.

Also ein Frame ist sowas wie.

Also wenn ich jetzt über die, wie viele Frames hat man sowas bei normalen Fernsehfilme wie 30 oder 60 oder sowas?

Normalerweise so 24, 25.

Natürlich gibt es da ganz tolle neue Technologien mit 48 Frames die Sekunde.

Ich glaube, Herr der Ringer hat das eigentlich.

Also für jede Sekunde von diesem Film musst du halt zwei Tage einplanen.

Ja, beziehungsweise wir haben da Render.

Das heißt,

drei Minuten pro Jahr schaffst du dann.

Ja, es gibt da so tolle Statistiken.

Ich glaube, ich habe mal gehört, bei den Transformer-Filmen, da hatten sie Frames, die haben 72 Stunden gerendert.

Wow.

Also, und dann stellst du fest, ja, nee, ist kaputt.

Ja, da muss man halt dann tatsächlich an anderen Stellen skalieren, da muss man mehrere parallele Renderinstanzen haben, weil ansonsten besser tatsächlich.

Du hast ja schon eine Renderfarm.

Musst du deine Renderfarm parallelisieren?

Irgendwann wird es ein bisschen wird es ein bisschen schwierig, klar.

Und wahrscheinlich ist es ja auch so, dass je, also ich meine, gut, das ist ein völlig anderer Bereich, aber das ist halt auch beim, wenn man jetzt so Data Science Machine Learning-Geschichten macht, da hat man auch so rechenintensive Jobs.

Also wenn man jetzt Modelle trainiert und sind zwar auch Tricks das zu beschleunigen, aber dann muss man halt abwarten.

Und abwarten ist auch mal ganz schlecht.

Also wenn man irgendwie so auf irgendwas ein paar Stunden warten muss, dann reduziert das die Gesamtperformance enorm, weil oft nach ein paar Stunden man sieht, das war alles Unsinn und muss halt nochmal machen.

Und die paar Stunden sind dann einfach weg.

Und wenn man lange braucht, um irgendwas zu rennen und sieht dann oh Mist,

also fast eine Woche.

Meine Figur hatte die ganze Zeit, weiß ich nicht, die Augen zu oder das Grinsen ist einfach schief, dann muss man nochmal von vorne anfangen.

Ich habe keine Ahnung, ich stelle mir das so vor, dann ist das blöd, wenn die Iterationen zu lange sind, ja.

Genau.

Also natürlich gibt es da auch wieder Tricks und Kniffe, dass man sich so, ähm, es gibt zum Beispiel progressives Rendering.

Da fängt der Renderer an sich schon sehr, sehr grob an und wird dann einfach mit der Zeit immer feiner.

Aber dem Menschen ist das quasi schon gegeben, dass du siehst, okay, ja, ja, wird, wird, wird, okay, einigermaßen okay und danach, nee, hier ist das Licht aus, alles klar, ich mach dir mal die Lampe wieder an.

Und dadurch lassen sich Fehler auch von vornherein relativ schnell beheben.

Das Problem ist halt nur, wenn du, keine Ahnung, du hast deine drei, vier Sekunden, die du da füllen musst, dann du kannst du nicht jeden Frame jetzt einzeln abwarten und gucken, ob das überall okay ist.

Also schickst es auf die Render Farm und musst dann halt warten und gucken danach, ob da alles okay ist.

Das Qualitätsmanagement ist da ja auch jedem selbst überlassen.

Also die Render Farm, vielleicht kannst du noch kurz mal, was eine Renderfarm hat.

Also wir haben quasi einen Satz Rechner in unserem Serverraum, ich glaube, sind wahrscheinlich jetzt um die 60, die für nichts anderes da sind, als die schönen Bilder zu berechnen.

Sprich, wir senden denen Jobs hin und sagen, okay, hier guck mal, hast meine Szene, rechne einfach mal aus.

Und dann gibt es so eine Renderfahrmanager, die im Übrigen auch alle wunderbar in Python geschrieben sind.

Es gibt ein Thinkbox Deadline, komplett in Python geschrieben.

Ich glaube nur unten an der Basis so ein paar C-Sachen und einzelne Programme.

Aber damit lassen sich dann auch die Sachen komplett steuern, dass du sagen kannst, okay, ich habe hier meinen Job von 100 Frames.

Bitte verteile mir die auf meine 30 Blades und jeder Blade bekommt fünf Frames.

Also die einzelnen Rechner heißen Blades bei uns.

Okay, wirklich fangen.

Genau.

Und dann siehst du halt in einem kleinen User-Interface, okay, mein Job muss leider noch ein bisschen warten.

Da sind noch fünf andere, die erstmal hier meine Sachen zurechtrücken müssen.

Und danach bin ich aber dran und dann wird das durchgerechnet.

Das bekommt dann nochmal so ein extra Layer von Komplexität drauf, wenn es dann Richtung Software-Licensing geht, weil natürlich werden natürlich noch Lizenzen verkauft für die Headless-Programme.

Sprich, wenn du Maya, nee, Maya nicht, aber Houdini im Headless-Modus rendern lassen möchtest, dann musst du dafür aber eine bestimmte Lizenz haben.

Davon musst du deine Renderfarm wissen und das Rendering am Ende auch.

Das muss man, es gehört aber quasi auch zu meinem Job, das alles zu organisieren, dass das am Ende passt.

Die IT, die kümmert sich dann im Grunde genommen nur noch darum, dass die Lizenzserver aufgesetzt werden und ich bastel dann die Programme so zusammen, dass dann am Ende die Lizenzen auch da landen, wo sie sein sollen.

Das ist quasi auch Teil meines Arbeitsberufs oder Alltagslebens.

Ja, ja, ja.

Nee, interessant.

Und wo, also die Daten, wie werden die Daten eigentlich gespeichert?

Die landen auf einem zentralen File-Server oder habt ihr da so eine Art verteiltes Dateisystem, irgendwie sowas wie bei Hadoop, HTFS oder keine Ahnung?

Es gibt einen zentralen Server, auf dem landen alle Daten, auf den haben eben auch alle Zugriff und genau, von dem wird alles gezogen und alles hingespeichert.

Genau.

Ist eigentlich mit der einfachste Weg, vielleicht nicht unbedingt der sicherste, wenn man mal Sachen verschiebt oder aus Versehen löscht oder so.

Aber das hat sich eigentlich schon sehr lange bewährt in der Industrie.

Jochen hat gerade kurz mit den Schultern gezugt, also nach dem Motto, ja, passiert halt.

Wenn man es wirklich nicht verlieren will, so Methoden, wie man das irgendwie sicherstellen kann.

Ich überlege nur gerade, weil ich zu Hause auch mal überlege, was ich für ein Netz verlege und ich bin jetzt so bei 10 Gigabit-Kabeln, aber tatsächlich kann ich das noch nicht wirklich nutzen, weil die Switches sind halt irgendwie, die haben halt Lüfter drin, die das können und das ist einfach zu laut und da habe ich keine Lust drauf.

Aber das muss ja dann wirklich schnelles Netz sein.

Weißt du, womit ihr das hinbekommt?

Weil man muss ja dann, wenn man so große Datenmengen übers Netz immer schiebt.

Das Netz ist weitestgehend mit Glasfaser überall ausgestattet.

Ich kann dir keine genauen Details nennen, weil ich bin quasi nicht unbedingt für IT-Zustand.

Achso, nee, nee, aber ich meine jetzt.

Wenn man an einem Rechner arbeitet, dann muss da ja auch irgendwie Netz reinkommen.

Das ist aber wahrscheinlich kein, also wenn man jetzt irgendwo an einem Rechner dran sitzt oder ist das auch, haben die Karten mit Glasfaser hinten dran?

Ja.

Achso, okay.

Gut.

Ja, das geht natürlich auch.

Ich hätte jetzt eher gedacht, dass das irgendwie Thunderbolt ist oder weiß ich nicht, irgendwie 10 Gigabit in eine Ethernet oder sowas.

Aber ja, okay.

Genau, also es ist ein Mix.

Wir haben, glaube ich, auch noch ein paar 10 Gigabit-Leitungen.

Das geht auch, wenn man jetzt nicht total alles hochfährt.

Aber wir hatten schon Zeiten, wo wirklich die Renderfarm ran voll war, keine Ahnung, 20, 30 Leute gleichzeitig aufs Netzwerk zu greifen.

Und dann beschweren sich natürlich alle.

Warum ist denn alles so langsam?

Kann man im Endeffekt auch nicht so viel machen.

Es gibt natürlich noch ein paar Tricks und Kniffe, dass die Programme zum Beispiel, die cachen sich die Dateien einfach runter lokal.

Und wenn du es einmal lokal hast, dann belastest du natürlich das Netzwerk nicht und hast auch wesentlich mehr Speed.

Das ist so ein bisschen Peer-to-Peer-Denke, ne?

Genau.

Das ist eine gängige Methode.

Meistens hat man dann einfach so eine Scratch-Disk noch, die man mit einer schnellen SSD, die musst du natürlich alle, jedes Jahr wahrscheinlich einmal austauschen.

Aber dafür hast du eben ordentlich Performance hinten dran.

Das ist schon sehr sinnvoll im Endeffekt.

Ah ja, okay.

Aber dann sozusagen immer einen Fileserver zentralen File-Server, also Quelle der Wahrheit, was da liegt, ist dann eigentlich das, was ist, was dann dabei rausgekommen ist irgendwie, ne?

Ja, okay.

Das ist schon interessant, also wie man so mit so Merge-Konflikten umgeht dann an der Stelle, ne?

Also werft welche.

Ich überlege auch gerade, ob es da irgendwie sowas wie Git oder so geben könnte, keine Ahnung.

Hatte ich auch alles schon mal angedacht.

Ich meine, Git und Git LFS hört sich alles gut an, ist aber relativ schwierig und die Lernkurve dafür finde ich auch ziemlich hart für jedermann.

Es gibt aber Unreal Engine.

Das ist auch wieder aus der Gaming-Szene tatsächlich.

Das ist aus der Gaming-Szene, genau.

Die haben zum Beispiel eine Git LFS-Anbindung, dass man rein theoretisch sein Projekt komplett über Git LFS machen kann.

Macht, glaube ich, keiner.

Aus genannten Gründen.

Beziehungsweise ich kenne niemanden.

Was ist denn das Problem an dieser Learning Curve bei Git LFS?

Na, man kann relativ viel immer noch kaputt machen, bis man quasi so in diese Arbeitsweise reingekommen ist von, okay, ich stage meine Sachen, dann commit ich sie, dann pushe ich sie, okay, ich muss die aber auch wieder runterpullen und dabei dann eben auch aufpassen, dass meine Pre- und Post-Commit-Hooks da alle mit Git LFS alles das machen, was sie sollen.

Ja, ich glaube,

er schwierig wird es halt tatsächlich bei so einem Mirchkampf kicken, weil du halt nicht einfach hast.

Man kann es halt nicht quoten, ne?

Genau, also du kannst den Quote nicht zusammenfügen, einfach so und sagen, die Stelle ist jetzt okay, die nicht, sondern du kannst dich halt wahrscheinlich nur für so einen Entweder- und Oder unterscheiden.

Also entweder das Bild vom Server oder halt mein Bild irgendwie und das wird halt bestimmt schwierig.

Ja, ganz genau.

Das ist zusätzlich noch so.

Auch da haben aber die 3D-Programme zum Teil noch ganz gute Kniffe, weil deren Pfeilformate sind meistens auf ASCII ausgelegt.

Okay.

Sprich, wenn man ein bisschen findig ist, kann man die einfach selbst aufmachen und da ein bisschen drin rumfuhr werken und am Ende sogar seine Szene retten.

Also funktioniert manchmal, manchmal funktioniert es nicht.

Aber auch da sehr clever.

Ich überlege gerade, was halt passiert.

Also ob so eine Videoproduktion aus mehreren Schichten besteht, wo es halt quasi ein Urbild gibt, also quasi das, was eine normale Kamera aufgenommen hat und dann die einzelnen Effekte drüber geleakt werden, einer nach dem anderen.

Oder ob die alle irgendwie gemircht werden und dann alle gleichzeitig irgendwie ablaufen und welcher halt dann der, der ist, der am nächsten an diesem Realbild dann dran ist oder so.

Okay, gehen wir von einer normalen Produktion aus, wie wir sie gerade haben, mit echtem Footage.

Sprich, du hast, keine Ahnung, Superman und hast ihn vor einem Greenscreen gedreht.

Sprich, schöne grüne Leinwand.

Und der soll jetzt erstmal schön durch den Himmel fliegen.

Dann wird's wahrscheinlich der Job von dem 3D-Artist sein, dass der dir erstmal einen schönen 3D-Himmel baut.

Kana.

Noch ein paar Wolken mit rein, das jetzt alles schön mitmacht.

Und dann gibt's, wenn diese Layer quasi fertig sind, noch den Job des Compositors, der diese Layer zusammenfügt.

Sprich, der sieht dann zu, okay, den grünen Hintergrund, den machen wir mal weg.

Dann sehen wir noch zu, dass wir hier noch, keine Ahnung, das Cape flattert noch ein bisschen, da war noch ein Kabel dran, das geht auch noch mit da weg und ja, damit jetzt die Wolken hier auch noch so schön aussehen, muss ja eine Wolke davor und eine Wolke dahinter, dass der da schön durchfliegt.

Das ist dann eher eben dessen Job.

Und zusätzlich kommt auch dazu, dass man dann meistens noch so farblich ein paar Sachen anpasst, weil das, was du in 3D renderst, ist dadurch, dass es artificiell ist, eigentlich sehr schwer mit Echtzeit abzugleichen.

Also was mit dem echten, was in einer echten Kamera gefilmt wurde.

Ich meine, man muss sich ja nur vorstellen, okay, ich filme das echte Leben draußen und da sind ja wahnsinnig viele physikalische Sachen am Werk.

Keine Ahnung, Lichtbrechung, Reflexionen, so Licht schimmert durch Bäume und wird absorbiert und wieder zurückgeworfen, hundertmal.

Und wenn wir das alles wirklich physikalisch durchrechnen würden, ja, dann würden wir auch in einem 3D-Programm auf das exakt gleiche Bild kommen, würden aber auch Ewigkeiten warten.

Sprich, man nimmt eine Menge ab.

Ja, die klingt erst hoch, ja.

Absolut.

Also jeder Simulationsart ist, der in den Himmel guckt und ein paar Wolken sieht, denkt sich so, ach, ja.

Kleine Kumulus-Cloud, ach, Nächtzeit.

Genau, deswegen nimmt man eine Menge Abkürzungen und der Compositor zieht das dann quasi wieder zusammen und blendet quasi die Tricks, die da so sind, wieder zusammen.

Aber wenn ich das richtig verstehe, ist halt quasi das Einzige, was uns daran hindert, so wirklich so live richtig tolle Echtbilder zu machen, so die Rechenpower, die dahinter steckt.

Ja, im Grunde genommen schon, ja.

Ich meine, gute Software wäre auch ganz nett dazu, aber ja, es ist einfach die absolute Rechenpower, die dahinter steckt, die man da eben braucht.

Ich meine, es gibt ja bestimmte Programme keine.

Unreal Engine schreibt sich ja auch auf die Fahne, dass die da wunderbar realistisch sind und du die tollsten Games mitmachen kannst.

Aber auch die benutzen halt ihre eigenen Tricks und Kniffe, dass sie halt sehr viel vorberechnen und dann wieder benutzen.

Die haben sich ja auch die haben sich natürlich im Laufe der Jahrzehnte jetzt schon entwickelt, ne?

Und früher war das natürlich bestimmt noch viel aufwendiger.

Also gibt es da irgendwie so einen Faktor, den man sagen kann, so ja, wenn es jetzt noch so zehnmal schneller wäre, dann wäre es halt irgendwie total cool oder so.

Oder wenn es jetzt noch hundertmal schneller wäre, dann wärst du so wie in echt.

Oder würdest du sagen, ja, okay, da ist noch wirklich richtig viel zu tun?

Es entwickelt sich in sehr vielen Enden, in sehr viele verschiedene Richtungen.

Also ja, es gibt schon Möglichkeiten, wie du Sachen in Echtzeit dir anzeigen lassen kannst und so.

Es ist quasi mehr eine Art und Weise, wie du selbst arbeitest.

Kannst du damit leben, dass du gerade nur eine graue Kugel siehst oder möchtest du den Fußball wirklich voll ausgeleuchtet mit allen Lichtern an und schön austexturiert?

Und genau, im Endeffekt ist es da so ein bisschen, auf was es einen selbst drauf ankommt.

Das, was am Ende auf der Leinwand passiert, ich meine, das ist ja dann eh fertig berechnet, das ist ja dann eh immer flüssig und schick.

Bei Game Engines müssen natürlich noch entsprechende Leute ran, dass das alles flüssig läuft.

Aber für die Film- und Fernsehbranche ist es ja fast irrelevant, weil das Endprodukt wird immer gut aussehen.

Oder sollte immer gut aussehen.

Das heißt, es geht tatsächlich darum, wie du als in deinem Zwischenschritt, was für eine Visualisierung du von deiner akuten Arbeit hast, also wie du quasi direkt eingreifen kannst und wie gut das visualisiert ist, was du da machen willst.

Genau.

Theoretisch könnt ihr also immer die Pause knopf drücken und dann 72 Stunden rendern lassen und dann hättest du das quasi jetzt Bild in super toll und dann machst du halt dann da weiter.

Und dann ist natürlich dann für den Zwischenschritt wieder nur, wie du sagtest, in grauen Kugeln oder so.

Genau.

Das könnte man so machen, wenn man denn wollte.

Genau, und deswegen gibt es auch immer wieder so Zwischenschritte, wo man das macht.

Animatoren zum Beispiel machen gerne Play Blasts.

Das sind wirklich nur sehr simpel gerenderte Szenen, wo sie quasi ihre Animationen einmal flüssig abspielen können.

Oder einmal flüssig sehen, nur als Bildmaterial.

Du hast dann halt, okay, du hast deinen Charakter vielleicht als grauen Menschen, aber es ist ja eigentlich egal, wie.

Ob wenn er sich an die, keine Ahnung, ans Kinn greift, dann ob er nun blau oder grün ist, ist ja nun wirklich wurscht eigentlich.

Genau.

Die Bewegung an sich ankommt dann, ja, und die kann man halt dann anders darstellen.

Da braucht man halt den Rest nicht dazu.

Das heißt, man reduziert quasi verschiedene Dimensionen, um sich auf das zu konzentrieren, was man gerade modellieren möchte.

Genau.

Im Grunde genommen ist es das.

Ich meine, vielleicht landen wir irgendwann mal in einer Welt, wo alles sofort immer echtzeit physikalisch machbar ist an allen Programmen, aber noch sind wir nicht da.

Aber ich meine, die Rechenpower und so, die wird auch immer besser.

Ja, klar.

Ich meine, kann man sich da nicht vielleicht auch einem der Tricks bedienen, den die Spiele besser aussehen lassen?

Ich meine, da wird ja jetzt inzwischen fast alles in GPUs gerechnet.

Gibt es da eigentlich irgendwie einen, wird das jetzt auch beim Rendern gemacht oder ist das alles noch CPU oder

es gibt schon Hybridränder, die sogar beides benutzen können, GPU und CPU.

Das große Ding ist immer der Speicherplatz auf deiner Grafikkarte.

Ah, ja, ja.

Also wir haben zum Teil Texturen, sprich das so wie, keine Ahnung, wenn du eine Jacke anhast, dann ist da eben der Jeansstoff drauf, so wie da eben aussehen soll.

Und das sind halt auch nur Bilder und die sind im Durchschnitt bei uns 4K groß.

Sprich 4096 mal 4096.

Das frisst dann gerne mal so 300-400 MB auf deiner Grafikkarte.

Dann hast du von den Dingern 10 und dann ist die voll.

Und dann warst du dann warst du auch wieder mit Echtzeit.

Ja.

Also Neukarten, die können relativ viel von sowas machen, ne?

Ja, ja.

Wird auch immer besser.

Also ist auch wirklich toll, was sie inzwischen damit können, aber wir haben auch massenhaft Daten, die wir da versuchen rauf zu pressen.

Und irgendwann gibt es halt den Cut, okay, Grafikkarte voll.

Ich benutze wieder die Festplatte und trittst du erstmal wieder schön auf die Bremse.

Ja.

Das Interessante ist auch, irgendwer hat das mal gesagt, die 3D-Branche ist schon peinlich parallelisierbar.

Sprich, wenn man so eine 3D-Szene hat, die ist so in sich abgeschlossen, dass man die unheimlich gut multithreadten und parallelisieren kann.

Weil es ist ja quasi alles bekannt.

Es ist alles da, es ist alles eingestellt.

Also du kannst jedem Chor quasi sagen, okay, du fängst da an, du fängst da an.

Ja, von der Zeit her kann ich mir vorstellen, dass das sehr gut möglich ist.

In einem Bild zerlegen stelle ich mir das schwer vor, wenn irgendwo eine Lampe über das ganze Bild leuchtet, dann muss, äh dann hängen ja die Sachen voneinander ab, ne?

Aber ja.

Man kann natürlich in der Zeit super, kann man das splitten, ja.

Ja.

Sprich, die Renderer gehen natürlich auch voll auf Kores ab.

Also wenn du da einen Threadripper drin hast, das merkst du halt definitiv.

Ja.

Auch sehr spannend, ja.

Ja, ja, und wenn man dann halt eben beliebig viele Rechner hat, dann ist das auch im Grunde ja nicht so schlimm, wenn das CPU muss man halt einfach nur mehr Rechner nehmen.

Ich finde auch spannend an der Stelle, dass Python da auch wieder reinkommt, weil Python an sich ist ja, ich meine, verschrien langsam als Skriptsprache.

Aber das ist unheimlich egal an dieser Stelle.

Weil was ich an der Sache mache, ist quasi einfach, okay, die Leute kriegen ihre Daten an der richtigen Stelle und ob das jetzt hundertmal schneller oder tausendmal schneller funktioniert, ist vollkommen egal.

Das ist so ein wunderbarer Use Case von, okay, muss die richtige Sprache benutzen für den richtigen Anwendungsfall.

Ich kann das alle, ich kann nicht, aber man könnte das alles in C ausprogrammieren, wer so wahnsinnig ist.

Dann wäre es auch wahnsinnig schnell, aber es macht keinen Unterschied.

Nee, nee, klar, also manchmal ist die Geschwindigkeit, mit der man irgendetwas hinschreiben kann, halt die viel wichtigere, wenn Dinge halt nicht so oft ausgeführt werden.

Nee, aber ich meine, ich spielt das eigentlich bei euch irgendeine Rolle.

Man könnte ja auch Dinge dann in Python schnell machen.

Also eben im Bereich Machine Learning und so, da wird ja auch tatsächlich viel selbst in Python gemacht.

Und ich weiß jetzt nicht, wie es mit Bilddaten aussieht und so, aber man könnte da ja auch, weiß nicht, indem man das Ganze zum Beispiel die Bilder irgendwie in NumPy-Arrays hat oder so, dann und dann darauf irgendwelche Transformationen machen oder so, das müsste dann eigentlich auch schnell sein.

Oder dass man halt irgendwie, keine Ahnung, per Seiten halt irgendwie Python-Code in oder die zumindest die heißen inneren Schleifen und Funktionen halt sozusagen in C zuerst übersetzt und dann wieder als C-Modul wieder einbindet.

Damit könnte man es ja auch sehr schnell machen.

Wird das irgendwie verwendet oder ist das, also da, wenn, ich meine, solange Python halt zum Steuern verwendet wird, ist es ja egal im Grunde, da brauchst du das alles nicht.

Es wird jetzt immer interessanter mit dem Machine Learning, weil es gibt so gewisse Schritte in der 2 und 3D-Bearbeitung, die halt unheimlich nervig und langweilig sind.

So das beste Beispiel ist Sachen ausschneiden.

Sprich, okay, man geht von A nach B, schneid den mal aus.

Und das lässt sich unheimlich, was halt, nee, also unheimlich gut noch nicht, aber es lässt sich langsam machen mit Machine Learning.

Wir hatten da schon erste Ansätze, allerdings muss man da auch schon noch durch ganz schön viele Hoops springen, bis man da ankommt, wo man hin will.

Aber so automatisiert Sachen ausschneiden, das wird echt unsere Branche nochmal ganz gut aufmischen.

Genau.

Im Moment hapert es noch an so der Größe der Bilder zum Beispiel.

Die meisten gehen da so auf 512 mal 512 Pixel verständlicherweise.

Ja gut, wenn du jetzt so ein 4K-Bild hast, dann musst du das erstmal zerlegen in, keine Ahnung, 8 bis 12 Bilder oder so.

Die du dann einzeln dadurch jagst, hast du im Endeffekt auch nicht mehr so viel gewonnen, weil das, was am Ende rauskommt, ist auch, naja, sagen wir mal, 80% da, wo es eigentlich sein sollte.

Und man kommt dann noch an so andere Probleme, wie zum Beispiel, ein Mann geht durchs Bild.

Ja, okay, den Mann kannst du ausschneiden.

Okay, jetzt hat der Mann aber auf einmal einen Hut auf.

Dafür ist jetzt das Maschine Learning-Modell aber nicht trainiert.

Das ist nur auf Menschen ohne Hüte.

Gibt es nur in den Trainingsarten, in den Trainingsatten waren kein Hüte drin.

Tja, das ist doof.

Okay, jetzt darfst du es erst noch trainieren auf Hüte.

Das ist ja auch irgendwie schwierig.

Aber ja, da gibt es auch jetzt erste Fortschritte.

Es wird auch noch sehr interessant für zum Beispiel so, keine Ahnung, wenn du Sachen verschönern willst, keine Ahnung.

Der Tom Cruise hat einen Pickel auf der Stirn oder so und bewegt sich durchs Bild.

Oh, und jetzt muss das aus jedem Bild raus retuschiert werden.

Genau.

Da ist Machine Learning aber auch schon ganz gut am Start und die Ergebnisse sind eigentlich sehr, sehr gut, muss man sagen.

Da hätte vorher dann halt ein Artist irgendwie eine Woche dran gesessen.

Und wenn das ein Rechner in einer Stunde kann, dann ist das definitiv cool.

Ja, ja.

Ja, ja, ja.

Ja, witzig, ja klar, da gibt es natürlich auch jede Menge Anwendungen dafür.

Ja.

Ja, oder da gibt es was, was ich ab und zu sehe ich mal so Demos.

Ich habe aber keine Ahnung, inwiefern das schon soweit ist, dass man das benutzen kann, dass man halt sagt, okay, also alles, was so in die Richtung Style gern, also diese Generative Adversarial Networks geht, dass man sagt, okay, man hat jetzt hier ein Bild von, weiß ich nicht, irgendeiner Kirche oder so und das hätte man jetzt gerne in einem anderen Stil und dann models das Ding halt irgendwie um oder man hätte jetzt gern irgendwie da einen Baum davor oder solche Sachen.

Nein, das würde noch sehr spannend.

Aber ist wahrscheinlich jetzt noch nicht wirklich vermittelt.

Ich stelle mir solche Dinge vor, du beschreibst deine Szene in Worten.

Ja, das gibt es auch.

Es generiert dir dann tatsächlich daraus dein Gedankenuniversum oder sowas.

Du könntest zum Beispiel schreiben, ich hätte gerne eine Kirche mit so und so viele Fenstern und einem langen Gang und 15 reinen Bänken.

Ja.

Ja, genau, das gab es schon.

So aller Holodeck, dass du eben dann wirklich nur, ich weiß ja nicht mehr, wie das Programm hieß, aber es war wirklich so, okay, ich habe einen Tisch, da sind vier Stühle dran, da sind noch eine Serialenschlüssel obendrauf und

das wird dir dann mega, mega, mega krass interessant.

Also wenn du das dann hinbekommst mit sowas wie der Unreal Engine und dann halt das augmentiert, eine virtuelle Realität auf irgendeine Brille projizieren kannst, die das in, weiß ich nicht, pro Auge 8K darstellt und in bitte nicht 24, sondern 60 FRS oder sowas in live.

Und dann kannst du dir deine eigene Realität zusammenreden, weil die KI, mit der du redest, das in mehr oder weniger Echtzeit dann als Darstellung bauen kann.

Wow.

Ja gut, gut, die baut das dann halt so, wie sie das in ihren Trainingsatten erkennt und wie du dir das vorstellst, dass du das nicht mehr so gut verstanden.

Ja, aber das kann man ja dann antrainieren.

Das ist ja dann der Trick, dass man halt dann irgendwie selber

modifiziert und ich habe nochmal gerade geguckt, wo das herkommt.

Es gibt von OpenAI so ein Ding, das nennt sich Dolly oder Dolly.

Das ist auch von dem Namen her angelehnt an Wally, an diese Pixar, Pixel, an diesem Pixar-Film.

Und das macht halt eben Text zu Bildern und so.

Und das ist auch sehr, also die Demos hier sehen super aus, aber das Problem ist natürlich, die sind auch dann so ausgewählt, dass es halt natürlich ist.

Ja, natürlich.

Um genau das Ding halt dann zu bauen, dieser Komplexität in diesen 3D-Modellen, die halt mehr sind als irgendwie nur zwei Bilder, sondern die halt dann tatsächlich eine ganze Szenerie mit den ganzen physikalischen Eigenheiten dieser Rigs und die da drin stecken.

Und ich weiß nicht, was halt auch, also du hast jetzt gesagt, also okay, ich habe jetzt ein 3D-Modell, das ist ja so das Erste, dann ist das mit einem Rig gefüllt und dann wird das irgendwie texturiert und beleuchtet irgendwie, ja.

Und dann irgendwie platziert mit anderen Objekten und in Interaktion gesetzt und sowas.

Also das sind ja schon irgendwie so mehrere Komplexitätsschichten übereinander, die alle für sich schon schwierig genug sind, ja.

Also um darüber nachzudenken und also in der Realität zu platzieren.

Wenn ich jetzt irgendwie die Realität mir anschaue und isolieren möchte, dann bin ich da ja alleine schon sehr gut mit beschäftigt, glaube ich.

Genau.

Es nimmt halt sehr starke Komplexität an.

Je mehr du da hinzufügst, desto mehr muss man halt hinterher sein, das alles ordentlich aufzusplitten und.

Aber wenn das halt geht und das alles mit Python finde ich natürlich sehr cool.

Dass das wirklich möglich ist, also sowas mit, also ist er, das weiß ich gar nicht, ist dieser Renderer, den es da gibt von der Engine, ist der auch, also von der Unreal Engine auch Python getrieben?

Nee, also dieser Renderer von Unreal Engine, das ist wirklich interner C-Code, der das da betreibt.

Unreal Engine lässt sich aber auch inzwischen mit Python auch steuern.

Also es gibt halt tatsächlich so einen Rapper oder sowas, der halt sagt, okay.

Genau.

Ich glaube auch mit Lua übrigens, also falls da Ambitionen sind.

Aber Game Engines müssen einfach auf C-Code eigentlich gehen, weil das ist einfach viel zu langsam, was du mit Python da erreichen könntest.

Das würde niemals 60 FPS erreichen.

Also kann ich mir nicht vorstellen.

Ich meine, es gibt natürlich so Sachen wie Pygame zum Beispiel, mit denen man sich so sein eigenes kleines Python-Game zusammenschreiben kann.

Ich weiß aber nicht, inwiefern da 3D-Grafik mit drin ist.

Also.

Nein, nee, das ist keine Ahnung.

Da müssten wir jetzt ja den Herrn Spielmann fragen, der tatsächlich da ein bisschen tiefer drin ist mit seinem Steam.

Aber ja, es ist aber trotzdem sehr spannend, also was man damit halt machen kann, wenn du sagst halt, das Unreal Engine dafür, dass man C braucht.

Was ist denn das, was die Geschwindigkeit dann tatsächlich gibt?

Ist das das Rechnung mit irrationalen Zahlen?

Nee, nee, nee, also das, was Python, also ich kann, kannst du mal schon sagen, was Python langsam macht.

Also Dinge, die in Python sehr langsam sind, im Vergleich zum Beispiel zu C, ist halt sowas wie ein Funktionsaufruf oder halt ein Methodenaufruf.

Weil ich einfach Reference-Counting machen muss, oder warum?

Nee.

Deswegen, weil das halt, das ist halt richtig langsam, weil das ist halt nicht einfach nur irgendwie in C, wenn das dann halt kopiert ist, das ist halt irgendwie.

Eine SM da Anweisung, springe nach.

Ja, also genau.

Und dann, ja, das ist halt in Python nicht so.

Da passiert halt ganz, ganz viel.

Der ganze Overhead, also den ganzen Name mitfressen muss.

Ungefähr halt tausendmal so langsam.

Also wenn du in C einen Funktionsaufruf machst und machst du in Python ein, dann ist er in Python halt so, als würdest du das in C tausendmal machen.

Also weil ich tatsächlich irgendwie diesen ganzen Wraparound machen muss, weil ich die ganzen Namespaces mitfressen muss, weil ich die ganzen Variablen mit essen muss, weil ich die ganze Syntaktik schucker mitessen muss, oder warum?

Deswegen, weil das nicht ein Funktionsaufruf wie ein C ist, sondern das ist halt was viel, viel komplizierteres in Python.

Weil das halt auch was viel Dynamischeres ist.

Weil das halt eine interpretierte Sprache ist.

Das ist halt nicht einfach nur das.

Also das ist halt einfach was anderes.

Und das wirst du auch nicht los.

Aber sag mal, die Frage ist halt, ob du das machen musst unbedingt.

Du kannst natürlich auch einfach.

Wenn ich tausendmal schneller rechne hätte, wäre das schon mal ziemlich egal.

Ja, gut.

Aber den Unterschied wirst du immer merken.

Das ist, ähm, aber sozusagen, wenn du wenn du jetzt irgendwas ausrechnest oder so, da wird es, da ist es eigentlich im Grunde nicht mehr, da hast du diesen Unterschied halt nicht.

Also wenn ich in NumPy, weiß ich nicht, zum Beispiel eben zwei Matrizen multipliziere oder so, das wird schwer, das in C genauso schnell hinzukriegen.

Und das ist in Python ja auch einfach hingeschrieben, ne?

Da schreibst du halt dann A at B oder sowas und du A mit B multiplizierst, ist es halt sehr schön, einfach das hinzuschreiben und es ist halt trotzdem schneller, als wenn du es in C machen würdest.

Außer du machst es halt wirklich, du, ja, aber dann also in C ist es halt auch, ist es halt deutlich schwerer hinzuschreiben.

Weil da musst du halt dann gucken, dass das halt.

Ja, du musst die ganze Implementierung selber bauen, muss dann auch so gut sein, dass du halt die Implementierung in so super selbst baust, wie das halt nicht.

Ne, du musst halt dann auf dem Compiler sagen, jetzt hier bitte ich weiß, was ich tue, benutze diesen D-Instructions und ja, wenn ich jetzt die Vorschreife, äh, hier eine Vorschleife hinschreibe, dann meine ich nicht wirklich eine Vorschleife.

Das darf auch, die Reihenfolge darf sich auch ändern und keine Ahnung.

Und dann, wenn du das alles machst, dann ist es vielleicht genauso schnell.

Aber insofern, also für manche Sachen ist es in Python nicht schwer, genauso schnell zu sein.

Für andere Sachen ist es halt, ja, ist es halt schwer.

Wobei man da eigentlich dann auch mal insofern drum herum kommt, als man dann sagen kann, okay, entweder man nimmt halt sowas wie so ein Just-in-Time-Compiler, so ein Number oder man nimmt halt man nimmt halt ein Subset von Python, halt zum Beispiel sowas wie Seiten, kompiliert das nach C und dann in ein C-Modul und dann kompiliert man das C-Modul und importiert es wieder zurück.

Und dann ist es halt auch schnell.

Also es gibt da schon Möglichkeiten, das hinzukriegen.

Die Frage ist, naja gut, wenn man jetzt so eine Engine hat, die irgendwie.

Ja, du würdest ja eigentlich bitte sowas machen wie Game Engine.

Also ich glaube schon, dass man eine Game Engine in Python schreiben könnte.

Das geht schon.

Die Frage ist, ja.

Hm, ich weiß nicht, ob das jemand schon mal gemacht hat.

Ja, wahrscheinlich nicht.

Also das ist halt immer auch der größte Flaw, den Python immer so hat, wenn man dort unterhält, ist das halt für 3D-Sachen bis jetzt nicht so gut geeignet gewesen ist.

Oder was meinst du mit 3D-Sachen?

Ja, weil es halt diese Bibliotheken dafür einfach nicht gibt.

Also wenn ich jetzt in C oder C<unk> irgendwelche Frameworks habe, die ja vorher schon prädestiniert sind und das in Python einfach nicht den einfachen Rapper gibt, den man so gewohnt ist, wenn man den das in der Hand hat, sondern es hat einfach viel länger dauert, wenn man das

anders zu machen.

Ja, also für mich wäre die Frage halt, was du genau meinst, mit was da gemacht werden soll.

Vielleicht möchte ich tatsächlich sowas haben wie eine Figur, die animiert wird.

Ja, wenn die jetzt live Bilder sehen.

Genau.

Ja, denke ich, kannst du in Python wahrscheinlich ganz genauso schnell machen wie.

Oder ich würde sagen, die Zeit, die du brauchst, um das hinzuschreiben, da bist du in Python wahrscheinlich deutlich schneller und bist halt wahrscheinlich auch vom Code her schneller.

Ja, aber das ist noch eine Marktlocator, entweder.

Nee, ich glaube, ich weiß es nicht.

Ich meine.

Mein Eindruck ist immer, es ist irgendwie relativ schwierig, mit Python irgendwie zur Grafikkarte zu kommen.

Das ist irgendwie so.

Also ja, es gibt Anbindungen so für Pi OpenGL oder sowas.

Geht bestimmt, aber ich weiß nicht, so direkt die Grafikkarte anzusprechen, fällt mir jetzt persönlich nichts ein, wo man sagen könnte, okay, das ist, was man, äh, dass man sich da in Bibliothek reinholt, wo man denkt, okay.

Ja, ich kenne es halt nur aus dem Machine Learning-Bereich, da gibt es halt KUDA, das ist halt diese Bibliothek oder die, die, äh, von Nvidia.

Und damit geht das, aber ich meine, man normalerweise gibt man damit halt keine Bilder aus, sondern man berechnet halt irgendwie, keine Ahnung, eben sowas wie Matrizenmultiplikationen oder so.

Ja, aber da geht das, aber ja, es stimmt schon.

Es ist ätzend.

Man muss halt diese ganzen Bibliotheken installieren, das muss halt.

Man kann das jemand mal neu bauen und dann funktioniert das.

Das kannst du leider, das ist leider nicht so einfach.

Nein, okay.

Ja, das ist ja auch das Problem, also zum Beispiel für auch für diese ganzen Machine Learning-Geschichten kann man nur Nvidia-Chips verwenden, weil es gibt nur für Nvidia diese Bibliotheken.

Und ich glaube, die AMD-Chips sind halt auch ähnlich leistungsfähig im Grunde.

Aber kann man einfach nicht verwenden, weil es gibt diese Bibliotheken nicht dafür.

Daher, und das ist ja jetzt auch schon Jahre, da sind Leute dabei, das zu versuchen und es klappt halt nicht.

Daher, ich fürchte, das ist nicht so ganz einfach.

Es gibt dann so ein bisschen, es gibt von Intel, gibt es das irgendwie PlateML oder so, womit man dann auch irgendwie das auf anderen Architects, also ich weiß nicht, genau, also es funktioniert aber eigentlich alles letztlich nicht wirklich.

Da braucht man halt diese Unterstützung dafür und das gibt es halt nur für Nvidia eigentlich richtig gut.

Und es ist total hakelig, das zu installieren immer.

Also, und wenn man halt nicht aufpasst, ist es halt langsam hinterher.

Also es ist ja, also es ist ziemlich viel zu.

Deswegen hätte man da nicht wirklich Lust drauf.

Auf dem Bund, warum man dann Sprachen wechselt.

Nee, also für Machine Learning gibt es ja auch keine Alternative.

Da kannst du, zu welcher Sprache willst du da wechseln.

Da gibt es ja auch nichts anderes.

Nee.

Es gibt wirklich nichts anderes.

Also ja.

Du kannst halt, ja, du kannst halt C Plus los verwenden, aber.

Ja, aber wenn es um die Ausgabe geht, ja, nee, keine Ahnung.

Also ich habe ehrlich gesagt auch, also Pygame gibt es, ja.

Ne, ich weiß nicht, ob es da irgendwas gibt.

Aber ich denke mal, im Grunde müsste man das machen können.

Kann man der Grafikkarte nicht einfach irgendwas in den Hauptspeicher legen, in den Grafikkartenspeicher legen und dann sagen, zeig das mal an oder so, das müsste doch eigentlich gehen.

Aha.

Keine Ahnung.

Viel Spaß.

Mach mal deine Grafikkarte kaputt und erzähl uns davon.

Ja.

Kann man das, kann man das?

Kann man in den Grafikkarte mit sowas kaputt kriegen?

Hat ihr denn so Heiz kriegt oder sowas, oder?

Ausprobieren.

Ja, ja, ja, ja.

Interessant.

Ja, aber was wäre das denn, wenn du dir was wünschen könntest, weiß ich nicht, was dein Leben irgendwie einfacher machen würde.

Jetzt sozusagen in diesem Anwendungsfall für Python.

Was ist das, was dir da am meisten Schmerzen macht oder wo man am einfachsten irgendwas verbessern könnte?

Grundsätzlich Python 3.

Okay, das ist ja fast schon traurig.

Ja.

Also ich freue

mich schon auf Python 3.10 und ich denke mir so, ey, alles was danach oder davor war, das will ich nicht mehr benutzen und das ist halt erst.

Wann kommt das fast im August?

Ja, ihr glaubt gar nicht, wie sehr ich mich auf F-Strings freue.

Ich glaube, mein Code hat immer noch nicht einen.

Also das ist schon echt langsam haarig.

Was noch?

Das würde mich noch freuen.

Es gibt schon Ansätze, dass man, dass die ganze Industrie sich quasi standardisiert auf gewisse Bibliotheken, die dann auch nach und nach geupdatet werden.

Sprich, dass man sich alle einigen auf eine bestimmte Compiler-Version, bestimmte Python-Version, bestimmte andere Bibliotheken.

Und wenn sich da alle dran halten würden, das wäre super, dass man nicht so die ganze Zeit so zwischen diesen Inkompatibilitäten hin und her jumper hat.

Ja, ich hab gesagt, du möchtest ja nicht einfach irgendwie einen Pi-Entwinst installieren und dann irgendwie seine Versionen pinnen, sondern muss halt irgendwie mit den Restriktionen jedes einzelnen Programms, der Compiler des jeden einzelnen Programms zu arbeiten und dann seine Skripte quasi immer downgraden oder sowas, wenn man dann irgendwie auf so ein altes Python stößt, als er nicht mehr furchtbar vor, ich weiß nicht, ob ich Lust hätte, in Python 2 irgendwas zu machen.

Ja.

Also nur um nochmal so einen kleinen Ausflug zu machen, es war eigentlich bis jetzt immer in Maya so, dass dadurch das Python eingebettet war, musste Python den Kompilierer benutzen, den Maya benutzt.

Das ist aber nicht der Standard-C-Kompilierer, den Python normalerweise benutzt, sondern eine ältere Version.

Sprich, ähm, alle PIP-Module, die eine DLL in sich hatten, wie NumPy oder so, haben erstmal auf Anhieb nicht funktioniert in Maya.

Weil die Compiler einfach nicht miteinander kompatibel waren.

Das heißt, du musstest, ähm, wenn du NumPy benutzen willst, musst du es dir erstmal mit dem anderen Compiler durchkompilieren, bevor du es dann in Maya benutzen kannst.

Ja, okay, anstrengend.

Absolut, ja.

Und ich würde mir auch wünschen, dass die Branche mal so ein bisschen auf Python-Standards umsteigen würde, wie Pip und Pyenv und alles andere, weil wir sind quasi noch sehr, dadurch, dass die Python-Interpreter eingebettet sind, sehr angewiesen auf die Programme selbst.

Also wir machen sehr viel mit Environment-Variablen zum Beispiel.

Typischerweise so Python Path, habt ihr vielleicht schon mal, wenn man das vorher setzt, dann findet halt der Interpreter in den entsprechenden Faden dann die Module.

Aber ja, wir müssen uns die halt selbst zusammenklauben und selbst dann so ein bisschen unsere

Art reinhacken, alles injecten und dann läuft es dann.

Genau.

Aber habt ihr das mal probiert?

Ich meine, eben, ich stelle mir dann vor, genau, das Problem ist sozusagen, dass deine eben sowas wie NumPy oder so Paket, das du installiert hast, muss halt kompatibel sein zu dem Python-Interpreter, der in der Software drinsteckt, mit der du das verwenden willst?

Dein Maya NumPy für Maya und du brauchst dein, weiß ich nicht, Houdini-Numpai und musst das dann halt umbiegen.

Habt ihr mal probiert, das mit Conda-Paketen zu machen, weil in Conda-Paketen kann man solche Sachen ja auch mit reinbauen?

Das geht in Pip nicht, aber mit Conda müsste das eigentlich funktionieren.

Ich hatte bis jetzt noch nicht viel Zeit, mich in Conda einzuarbeiten.

Also ich habe es hier und da schon gehört, viel Gutes auch schon von gehört.

Aber vielleicht ist das mal ein guter Trick.

In Conda kann man sagen, welchen C-Compiler dahinter verwendet werden soll?

Nee, du kannst Binär-Pakete installieren.

Und du kannst vor allen Dingen auch nicht-Python-Pakete installieren auch.

Was auch sehr praktisch ist.

Ja, du kannst sogar so weit gehen, deine eigene Lib C mitzubringen.

Also du kannst halt quasi viel mehr mitbringen, als in einem PIP-Paket ginge.

Und natürlich hast du dann immer noch das Problem, dass Conda auch überhaupt gar nicht dafür gedacht ist, sozusagen, dass man halt.

Ja, grafische Oberfläche nicht mitladen willst.

Nee, nee, dass das halt, also dieser Use Case, dass du unterschiedliche Versionen von einem Paket hast für unterschiedliche InterpreterInnen, die eingebettet sind, dafür ist es auch nicht so wirklich gedacht.

Das ist schon ein ziemlich bizarrer.

Genau, du kommst daran nicht vorbei, dass du halt einen Python nimmst pro Programm, das du da verwendest.

Und die Frage ist halt nur, wie du quasi die geringste gemeinsame Basis findest, irgendwie das, was halt dann auf allen diesen Programmen dann irgendwie läuft.

Das Nervige, wenn dann halt irgendwelche Pfeil-Pfeil-Sachen drunter stecken,

ich weiß nicht, kann das sein, dass ihr das dann tatsächlich neu kompilieren müsst, wenn ihr das verwenden wollt und dann halt wartet, wenn das?

Also in der Frage von NumPy wäre das so, genau.

Man müsste es neu kompilieren, ja.

Genau, weil man konnte ja das auch irgendwie so, das halt sozusagen in allen für die entsprechenden Interpreter kompilierten Versionen irgendwo hinlegen und dann Tricks machen mit den Umgebungsvariablen oder so, dass dann halt das richtige Ding genommen wird, wenn man das.

Genau, also ja, also wir würden es vorkompilieren und dann.

Und dann irgendwo einlegen, ja.

Also ein sehr großer Teil unserer Bibliothek liegt auch mit auf dem Server und wird auch quasi die ganze Zeit dynamisch einfach nur hinverlinkt, damit auch absolut sichergestellt ist, dass jeder den gleichen Code ausführt.

Ah, ja, ja.

Also es gibt teilweise gibt es schon so Sachen, dass so Code quasi runtergezogen wird auf die lokalen Maschinen und von da aus dann executed wird, aber ein sehr großer Teil unserer Pipeline liegt halt immer noch auf dem Server zentral.

Was gut und schlecht zugleich ist.

Weil einerseits kannst du wahnsinnig schnell Sachen verändern, was manchmal einfach notwendig ist.

Andererseits ist es irgendwie immer die Operation am offenen Herzen.

Und es geht dann für alle gleichzeitig kaputt, wenn es kaputt geht, ne?

Ja.

Also, ähm.

Also patch dir dann wirklich auch die Module dann selber, quasi?

Genau.

Also wir haben ja unsere eigenen Module, die quasi mit unserer Logik da funktionieren und die patchen wir natürlich komplett selbst.

Für Third-Party-Sachen, die versuchen wir weitestgehend so gut es geht, unangetastet zu lassen, nur manchmal hier und da vielleicht so ein bisschen zu.

Kindermann zu binden.

Ja, ja.

So in der Art.

Aber ja, wir wollen uns da jetzt auch nicht ans Bein binden, da unsere, keine Ahnung, eigene Version jedes Mal hochzuziehen, nur wenn da ein Update kam.

Aber ja, eigentlich ist mir das auch immer so ein kleiner Dorn im Auge, dass das da alles immer so live ist auf dem Server und wir immer so ein Git Repository updaten und irgendwie naja.

Ich habe noch keinen wirklich guten Weg drumherum gefunden.

Vielleicht gibt es ja ein paar größere Experten, die hier auch mal hinkommen möchten und sich erklären möchten, wie das funktioniert.

Aber genau, also ja, diese Softwareinstallations-Story bei Python ist halt echt so ein Problem.

Das ist irgendwie nicht gut gelöst.

Das ist immer furchtbar.

Also habt ihr mal versucht, jemandem, der keinen Python kann, eine vernünftige, laufähige Python-Version, die auch irgendwie selber ein bisschen was kann, ohne jetzt irgendwie per Webinstaller irgendwie auf die Software was zu installieren?

Also ihn gut?

Also dass er selbst programmieren kann oder dass er selbst ein kleines

Programm bekommt?

Nein, dass er selber programmieren kann.

Also tatsächlich ist es eine vernünftige Bium-Hard, dass ein Interpreter hat, am besten noch mit einer vernünftigen Shell und integriert und mit vernünftigen Paketen und nicht jetzt irgendwie installiert in alle Pfade dieser jeweiligen Systeme, sondern nur die gute Version oder sowas.

Also eigentlich sowas wie ein, du hast ein Pi-Env installiert und du hast dann die Pfade vernünftig gesetzt und du hast dann ein PIP aktualisiert und vielleicht noch die Shell dazu aktualisiert mit einem Paketmanager, irgendwie so.

Also ich habe mal angefangen, so ein Developer-Environment-Skript zusammenzubauen, einfach für Leute, wenn ein neuer Developer kommt zum Onboarden.

Ich habe irgendwann, das ist so 50% fertig.

Also 50% musst du immer noch selber machen an der Stelle.

Aber grundsätzlich finde ich das eine interessante Idee, so Leute relativ schnell auch reinzubekommen.

Aber ja, wie du schon sagst, ist es halt nicht so ganz einfach.

Du musst halt alles selbst zusammenziehen, alles an die richtigen Stellen tun.

Ohne haben mich aufwendig und das ändert sich halt alles so schnell.

Das heißt, du musst halt halt fliegen, weil du kommst halt irgendwie nicht hinterher.

Und dass das dann gut funktioniert, ohne und auf unterschiedlichen Systemen mit unterschiedlichen Rechte, Verwaltungssystemen, die dann irgendwie installiert sind, das ist alles furchtbar anstrengend.

Und das ist nie so, dass es irgendwie, also jetzt auf verschiedenen Systemen Python nicht so integriert, dass man einfach sagen kann, hey cool, es ist da und rennen mal los.

Das ist wahrscheinlich auch der Grundfall, also ich glaube, die ganzen Programme, die du da verwendest, sind hauptsächlich auf Windows, ne?

Nee, hauptsächlich auf Linux.

Auf Linux.

Tatsächlich.

Es gibt ein paar Ausnahmen.

Photoshop zum Beispiel.

Aber warum verwenden die denn alle einen so veralteten Python-Interpreter?

Das verstehe ich dann wieder nicht.

Also wir arbeiten firmentern auch noch mit CentOS 7.

Auch da ist noch Python 2 Default installiert.

Und wie gesagt, die Branche ist unheimlich konservativ, was sie ihre eigenen Applikationen angeht.

Also machen Gottes Willen nichts kaputt.

Die meisten User sind sowieso schon angepisst genug von den ganzen Bugs, die sie immer mit reinbekommen in die neuen Versionen.

Aber ja, jetzt sind die meisten halt mal ins Feindewasser gesprungen.

Oh ja, davon haben wir einige.

Ja, es gibt ja diesen schönen Trend von jetzt einfach schon die nächste Jahreszahl immer an die Softwareversion mit ranpacken.

Also Maja 2022 und so.

Und naja, böse Zungen aus der Branche sagen dann immer, ja, das ist die Jahreszahl, wo du es verwenden kannst.

Ja.

Ja, also es gibt durchaus Hotfix-Patches, die sind 1,5 GB groß.

Also mit sowas schlagen wir uns auch gerne mal rum.

Rinats.

Tja.

Ja, ja, ja, ja.

Ansonsten, um so kleine Programme an User oder Leute rauszubekommen, kann ich echt PyPy-Installer nur empfehlen.

Das ist wirklich, wirklich cool.

Machst du aus einer kleinen Applikation einen einzigen Pfeil im Endeffekt und packst den irgendwo hin.

Funktioniert.

Derjenige braucht keinen Python installiert haben.

Der packt alles zusammen, was er so braucht.

Ich meine, klar gibt es ja hier und da noch so ein paar kleine Kniffe.

Der macht ein ganzes Fulder, oder?

Oder der macht halt nicht so wirklich so eine Extra mit External Dependencies.

Da muss man so ein bisschen noch fummeln und so Specification-Dateien irgendwie konfigurieren und sowas, damit es das macht, aber.

Genau, aber was er so Default macht, ist eigentlich schon relativ easy peasy.

Klar, je komplexer die Bibliotheken sind, die du nutzt, desto schwieriger wird das Ganze da zurechtzufummeln.

Aber im Endeffekt, ich habe sehr gute Erfahrungen damit gemacht.

Also wir haben auch so drei, vier, fünf kleine Applikationen in der Firma.

Die funktionieren damit tadellos.

Also je kleiner es ist, desto besser natürlich.

Ich meine, du kannst natürlich da auch sonst was reinknallen, wenn es dauert.

Ja.

Dann dauert das natürlich auch fünf Minuten, bis das Programm offen ist, aber braucht ja keiner.

Oh, das erinnere mich an.

Ich habe ein kleines Programm, was ich auch mit Pinesteller gepackt habe, als Binary geschrieben, das einen nichts anderes macht, als YouTube zu fragen, hey, gib mir mal diesen Link zu diesem Suchbegriff.

Dafür muss man ein YouTube-Api-Key bestellen.

Und ich muss jetzt ein Video einreichen, der beschreibt mal in meinen Workflow-Beschreibt, damit ich diesen API-Key ein Kontingent bekomme.

Hm.

Ja, traurig.

Ja, ein Screencast sollte ich machen.

Ja.

Aber das nur so als Beispiel für Sachen, die mein Pinzeller tun, das wäre eine ziemliche Querverknüpfung, aber.

Ja, ja.

Ja, ja, ich bin, äh, weißt du, es gab da, da habe ich denn auch nichts mehr von gehört.

Es gab da noch andere Ansätze.

Es gab zum Beispiel irgendwie den Ansatz des.

Nuitka gibt es da.

Genau, das gibt's noch, dann gab es noch, aber das war auch nicht das Tippe.

Es gab irgendwie noch das Tippe.

Wie hieß das denn noch?

Das hat irgendwie das in Rust geschriebene.

Achso, kann ich.

Ja, ich hab's auch gehört, aber ja, Rust installieren und so weiter.

Und dann gab es auch noch das von.

PyOxidizer?

Ja, genau, das ist richtig, genau.

Ja, ja.

Aber da habe ich auch länger nichts mehr von gehört.

Es funktioniert alles immer so im Mittel, ehrlich gesagt.

Dass irgendwie eins von den Dingen so unkompliziert mit jedem Paket funktionieren würde in jeder Größe und mir so eine Single Binary File baut, die auf einem System läuft, das kein Python-Franziert hätte, mit allem drin und ohne Probleme und alles direkt mit einpackt, was dazugehört mit den Dependencies, weil ich irgendwie nur, auf weiß ich, eine Pipo-Tech oder eine Requirement zeige.

Gibt's noch nicht.

Ja.

Ja, das ist wahrscheinlich auch einfach nicht so einfach.

Ja, warum denn nicht?

Sollen wir darüber noch eine Folge aufnehmen, warum das zum Einfachen?

Ja, ja, ja.

Ich weiß gar nicht, wie das hier Marc-André Lembock hatte ja auch so ein Ding geschrieben.

Das packt auch so Pakete.

Ja, und der macht da ganz schön viele Tricks.

Der packt das Ganze dann in so ein ZIP-Archiv, benutzt dann die Import, dass man daraus halt Dinge importieren kann in Fighten.

Dann strippt er da noch irgendwie die ganzen Kram raus, damit das halt deutlich kleiner wird.

Dann wird das halt irgendwie, ist das nur noch ein paar Megabyte groß.

Aber das ist, das sah auch schon, das sah auch schon nach fortgeschrittener Magie aus.

Auch trotzdem immerhin 20 MB oder so?

Nee, nee, weniger.

16?

Nee, 4, 5.

Und zwar komplette Standardbibliothek mit drin.

Ja, okay, ja, okay.

Also das ist schon sehr klein.

Aber funktioniert, glaube ich, auch nur auf Linux.

Tja, tja.

Ich glaube, wir sind beim Pick der Woche angelangt.

Ja, wollen wir.

Können wir gerne.

Ich habe mir was Grafisches überlegt.

Ja.

Da habe ich ja letzte Woche ein bisschen reingeguckt und zwar die Konsole grafisch.

Also Rich.

Fand ich sehr cool.

Das habe ich mit euch tatsächlich aufgestanden, ein bisschen ausprobiert.

Und das macht wunderbar die Konsole farbig und tolle Sachen, Inspection.

Ich weiß nicht, ob ihr Ice Cream mitbekommen hattet.

Man konnte irgendwie Ice Cream importieren.

IC und dann hast du einen.

Ach, der Debugger-Geschichte.

Ein Mini-Debugger, der quasi nichts anderes macht als ein Debug-Stable.

Aber da habe ich mir gedacht, nee, also Don Dochwitch, das macht genau dasselbe, auch so einen Inspekt quasi, der einem in einer Tabellenform ausgibt, alle nutzbaren coolen Methoden einer Klasse zum Beispiel oder einer Methode, eine alles aufrufbar.

Das ist echt cool.

Und alles farbiger Output in der Konsole einfach importieren und man kann quasi seinen eigenen Python-Interpreter damit pimpen, indem man das einfach lädt und installiert quasi live und schon ist alles farbig und cool und sieht schön aus.

Geht so rein, Dangro rein.

Tja, nice.

Das ist wirklich ziemlich cool.

Ich würde eins nehmen, das natürlich so ein bisschen in meine Branche fällt, nennt sich Invisible Watermark.

Da kann man, also Watermarken kann man ja Bilder eigentlich relativ easy, sprich, du kannst einfach so ein großes, fettes Firmenlogo quasi so halbtransparent über Bilder legen und dann weiß jeder, okay, nee, gehört dem oder dem.

Was aber interessant ist, dass es quasi unsichtbar Bilder zu Watermarken, dass du quasi einfach nur verschiedene Pixel, so die ganz leicht nuanciert, anders machst, dass du am Ende da quasi deine Daten reinpackst.

Das hat aber den Nachteil meistens, dass wenn du das Bild verkleinerst oder, keine Ahnung, spiegelst oder sonst irgendwas, dass dann diese Daten verloren gehen.

Aber diese eine Python-Bibliothek kann das so machen, dass du das Bild komplett noch vermuscheln kannst, Bilder, Sachen rausziehen kannst oder wie auch immer.

Und dein Watermark bleibt erhalten.

Also man muss aktiv diese Python-Bibliothek benutzen, damit das Watermark erhalten bleibt oder ist das auch für Dritte, die dann quasi das Bild bearbeiten, da ist Watermark noch drin?

Ähm, ich bin mir noch nicht sicher.

Ich habe es leider noch nicht ausprobiert.

Ich fand es nur mega cool.

Es ist, glaube ich, auch wieder Artificial Intelligence hier basierend.

Okay, es hört sich aber so an, als müsste man das selber aktiv anschließen.

Es gab sehr coole Bilder dazu.

Naja, ich, ich, ähm,

das klingt wie in den Shownotes.

Kann man mal reingucken.

Ja, ich habe immer das Problem mit diesen ganzen, also ich meine, Stiganografie funktioniert ja auch in gewisser Weise so.

Ich habe das aber auch lange nicht mehr verfolgt.

Also das letzte Mal, dass ich da irgendwie drauf geguckt habe, was da so passiert, ist halt schon lange her und das, was der zentrale Punkt, der mich immer dabei gestört hat, ist, dass man, sagen wir mal so, wenn man jetzt Verschlüsselung hat, dann brauchst du halt einen Schlüssel, um rauszukriegen, was da drin steht.

Und bei diesen Geschichten kriegst du es halt auch ohne Schlüssel.

Also was mich interessieren würde, ist, ob es sowas gibt.

Du kannst erst sehen, ob eine Information oder ein Worthammark dann in dem Bild oder in irgendeinem Audio oder Video, sonst was drin ist, wenn du den Schlüssel kennst.

Und sonst kannst du gar nicht rauskriegen, dass da irgendwas drin ist.

Und das Problem ist halt immer, das ist halt normalerweise nicht so, vielleicht hat sich das auch geändert.

Und du kannst halt immer zumindest sehen, was da drin ist.

Das heißt, du kannst da nicht irgendwelche Informationen drin verstecken.

Stikanografie.

Ja.

Und wenn du es halt sozusagen, aber immer wenn du halt tatsächlich einfach rauskriegen kannst, was da drin ist, ohne zuerst einen Schlüssel haben zu müssen, kannst du es auch eigentlich ja dann wieder entfernen.

Einmal das, oder du kannst es halt auch irgendwie verändern, oder du kannst halt auch sozusagen Dinge daraus lesen, die vielleicht eigentlich gar nicht.

Also insofern, ja, ich meine, um Sachen zu markieren, dass sie einem gehören oder so, ist wahrscheinlich alles ausreichend.

Ja, ja.

Der ist halt die Frage, wovon man es benutzen möchte.

Und ich hatte noch eine andere kleine Entdeckung.

Die ist zwar kein Python-Modul, aber ich finde sie trotzdem ziemlich cool.

Die nennt sich devdocs.io.

Und da.

Das ist im Grunde genommen eine Sammlung von Dokumentationen auch ganz verschiedenster Art.

Also ist nicht nur Python drin, ist auch C, C<unk>, Angular, you name it.

Und das ist sehr schön aufbereitet, ziemlich fix und es macht Spaß, da die Dokumentation drin zu lesen.

Also.

Hat mir meinen Arbeitsalltag ein bisschen versüßt.

Kann ich empfehlen.

Sehr schick.

Ja.

Mal kurz reingucken.

Ja, wunderbar.

Nee, das sieht gut aus tatsächlich.

Und da ist ja echt viel Zeug drin.

Oh ja.

Interessant.

Kann man sich das so ein bisschen Favorites machen.

Und dann kann man da Ratzbatz die Suche anschmeißen.

Funktioniert ziemlich cool.

Ja.

Ja, vielen Dank.

Ja, Moment, Moment, ich hatte hier auch noch einen.

Du hast auch noch mal einen.

Ja.

Und zwar.

Ich darf mich auch schon mal bedanken.

Und zwar hatte ich immer so das Problem, dass ich auch die Fischhell, so nachdem ZSH ja jetzt auf Mac OS irgendwie vorinstalliert ist, ist mir das zu mainstreamig geworden.

Da muss ich mal was Neues probieren.

Oh, cool, das ist Fisch.

Wir haben in der Fishhell gelandet.

Oh mein Fisch.

Und genau, aber da ist immer das Problem, dass wenn man jetzt die Py-Env-VirtualInvs verwendet, weil ich verwende normalerweise PyEnv, um halt unterschiedliche Python-Interpreter zu installieren.

Oder halt die von Poetry, dann funktioniert das mit dem Setzen des Prompts nicht immer richtig und das ist auch sonst irgendwie nicht so schön integriert mit Fisch.

Und man muss da irgendwie fiese Funktionen aufrufen und manchmal geht es kaputt und dann ist man auf dem anderen Rechner, da geht es auch nicht mehr.

Alles nicht so schön.

Da gibt es ein kleines Tool, was dem Abhilfe schafft und das ist VirtualFish und das ist sozusagen ein Virtual Env-Tool für Fish und das funktioniert ganz hervorragend.

Das benutze ich jetzt immer und das ist echt toll.

Ja, Virtual Fish mit Fuzzy Search, das ist schon.

Und ja, muss man benutzen eigentlich.

Genau.

Das nutze ich sogar auf den Windows-Rechner.

Ja, keine Ahnung, haben wir doch.

Also Virtual Fisch ist hoch im Kurs.

Fisch hat einige coole Plugins, müsst ihr mal reingucken.

Ja, nee, dann sind wir mit den Twitter.

Vielen Dank.

Vielen Dank, Jochen.

Ja, danke, danke.

Schreibt uns

alles, was ihr für uns haltet was ihr doof fandet, was ihr gut fandet.

An hallo.pythonpodcast.de.

Alles klar, tschüss.

Dann bis zum nächsten Mal.

Gute Nacht, bleibt uns gewogen.

Tschüss.