Immer noch Angst vor Processing?

Hey,

wir sind inzwischen weit gekommen, behandelt wurden einfache Formen, Klassen, die translate()-Funktion, Farben, das Koordinatensystem, Rotationen und vieles, vieles mehr. Der ein oder andere hat trotzdem immer noch Angst davor, sich die Programmiersprache Processing anzueignen. Vielleicht weil es „zu kompliziert“ ist oder du denkst „das bekomme ich nie hin“? Oder etwa weil das was du dir vornimmst einfach nicht klappen will? Dann solltest du jetzt weiterlesen, dieser Artikel ist für alle die immer noch so ihre Zweifel mit Processing haben – völlig zu unrecht, wie sich im weiteren Verlauf herausstellen wird…

Wieso gerade Processing, was bringt es mir?
Zuerst stellt sich (dir?) natürlich die Frage, wieso du gerade Processing lernen solltest. Nun, da gibt es -abgesehen davon dass man mit Processing richtig geile visuelle Effekte zaubern kann- schon ein paar Gründe. Processing ist in erster Linie kostenlos, und was nichts kostet kann man immer zumindest mal ausprobieren. Weiterhin ist Processing keine exotische Programmiersprache sondern lediglich eine vereinfachte Java-Version, welche sich per Definition dieser Sprache auf das wesentliche beschränkt. Daraus folgt, dass du zwar eine überschaubare Menge an Befehlen, allerdings dadurch aber auch weniger zu schreiben hast. Die Kunst, das besondere an dieser Programmiersprache ist nicht, mit unmengen an Befehlen und tausenden von Möglichkeiten irgendetwas zu realisieren.. nein, das besondere an Processing ist die enorme Vielfalt an Möglichkeiten die sich gerade mit diesen paar Hand voll Funktionen umsetzen lassen. Außerdem kann man mit Processing nichts falsch machen. Egal wie du an welcher Stelle im Code was schreibst, es kommt immer was dabei raus. Und um ein anderes Ergebnis zu erreichen musst du meist nicht einmal den passenden Befehl suchen sondern die Stellen im Code einfach nur etwas umstellen. Desweiteren läuft Processing unter Windows, Linux und MAC, und die Sketche die du mit Processing erstellst lassen sich in Webbrowsern als Applet einbinden.

Aber ist das alles? Was gehört denn dazu, Processing überhaupt erst zu erlernen? Außerdem könnte Ich ja was falsch machen…
Processing ist eine Sprache die man nur durch Selbst-ausprobieren erlernt. Und Processing ist auch nicht nur irgendeine Programmiersprache, Processing zu beherrschen ist eine Kunst. Gut, Ich sage ja generell, dass Programmierung nicht nur eine Fähigkeit, sondern auch eine Kunst ist. Andererseits geht es ja hier aber hauptsächlich um Visualisierung, unter dem Aspekt kann so der ein oder andere mit Processing erzeugte Sketch doch als Kunstwerk angesehen werden, schaue dir nur mal an was die Leute (und auch ich 😉 ) so auf OpenProcessing.org reinstellen.
Wo ich gerade auf OpenProcessing zu sprechen komme … falls du auf der Seite mal ein wenig gestöbert hast, wirst du du dir vielleicht doch hier und da mal gedacht haben „das bekomm ich so nie hin“. Die meisten Leute scheuen sich davor, weil sie Angst haben, etwas falsch zu machen. Aber mal realistisch betrachtet, was willst du falsch machen? Nimm dir doch von der Seite einfach mal einen Code der dir gefällt, und mach ihn kaputt. Scheißegal, einfach nur um zu sehen was passiert wenn man hier was weglässt, dort was hinzufügt oder umstellt oder verändert …. dabei findest du raus, wie der Code funktioniert, welche Stelle was tut, und das ganz nebenbei, ohne großartig zu lernen. Lernen kannst du eh vergessen, wie gesagt, Processing lernst du nur durch machen. Du willst dir gar nicht vorstellen wieviele Processing-Projekte auf meinem PC abgespeichert sind, und davon sind die meisten beinahe dieselben, die ich nur mehrmals abgespeichert hab‘, weil Ich an irgendeiner Stelle im Code was klitzekleines verändert hab und das Ergebnis einfach so geil aussah dass Ich es als eigenständiges Projekt abspeichern wollte. Viele Processing-Nutzer wissen wovon ich rede 😉 Aber genau das ist es ja, was diese Programmiersprache ausmacht, was sie so besonders macht.
Vielleicht hast du den Code von einem Sketch (von OpenProcessing oder von den Beispielen die das Programm von sich aus mit dabei hat) und hast keine Ahnung was dort drin steht, aber das beste was man in diesem Fall machen kann, ist einfach mal hier und dort eine Zeile zu entfernen um zu sehen, wie sich das im Sketch bemerkbar macht. So hast du eigentlich sofort im Kopf drin „ah, die Zeile raus und dann haben die Formen keinen grünen Rand mehr“ und merkst es dir dadurch quasi automatisch und ganz nebenbei.

Aber wie fang‘ ich an, ich kann doch nicht einfach irgendwas da reinschreiben
Und genau das unterscheidet Processing von anderen Programmiersprachen – es ist scheißegal was du dort in das Codefenster reinhackst, irgendwas kommt immer dabei raus. Zu Anfangs wirst du ohnehin keine großartigen Pläne machen, was genau du mit Processing umsetzen möchtest. Zum einen fehlt dir -logischerweise- jedes Wissen. Zum anderen: bei Processing musst du dich nicht auf die Befehle selbst konzentrieren, es sind schon einige, aber doch noch gerade so wenig, dass du sie mit der Zeit locker alle drauf hast. Dauert auch nicht lange, und manche Befehle wirst du möglicherweise nie brauchen weil du schon mit ein paar wenigen so viele Möglichkeiten hast, die verschiedensten Sketche zu programmieren. Weniger auf die Befehle selbst kommt es bei Processing nämlich vielmehr darauf an, wie du die Befehle einsetzt. Am Anfang bekommst du durch deine Codes sicherlich das ein oder andere mal ein anderes Ergebnis als du eigentlich erwartet hast. Manchmal „überrascht“ dich Processing einfach mit dem Ergebnis. Wenn du bevor du den Sketch ausführst schon sagen kannst, wie das Ergebnis aussehen wird, dann bist du auf dem besten Weg. Und das ist manchmal gar nicht so einfach, deswegen braucht dich das am Anfang auch nicht interessieren, das kommt mit der Zeit.

Ich bin noch nicht so ganz überzeugt. Du hast leicht reden, du kannst Processing ja bereits…
Ja, ich kann Processing bereits. Allerdings hab auch ich einmal klein angefangen, und von einem Profi bin ich auch noch ein gutes Stück weit entfernt. Bei mir war es so, dass ich in einer Zeitschrift (soweit ich mich erinnere war es die „c`t Programmieren“) einen Artikel über Processing gelesen habe, darin war unter anderem folgender Beispielcode abgedruckt:

// Stern interaktiv
// Den Mittelpunkt der Strahlen bestimmt der Mauszeiger,
// ein Mausklick speichert eine Momentaufnahme als Bitmap.float winkel;
float laenge;
float dx;
float dy;
int breite;

// Die Funktion setup() ruft Processing beim Programmstart einmal auf
void setup(){
size(600, 600);
background(15, 15, 20);
// Mauscursor wird als Hand dargestellt
cursor(HAND);
smooth();
// Bei Programmstart sollen die Strahlen vom Mittelpunkt des Fensters ausgehen
mouseX = width/2;
mouseY = height/2;
}

// Die Funktion draw() ruft Processing nach setup() immer wieder neu auf
void draw (){
// zufaellige Linienbreite
breite = int(random(1,7));
strokeWeight(breite);
// zufaellige Farbe (innerhalb gewisser Grenzen)
stroke (random (25, 150), random (5, 255), random(100));
// zufaelliger Winkel
winkel = random(0, 2*PI);
// je breiter sie sind, umso kuerzer sollen die Linien sein
laenge = random((min(width/2, height/2))*(7-breite)/6);
dx = cos(winkel)*laenge;
dy = sin(winkel)* laenge;
line (mouseX, mouseY, mouseX+dx, mouseY-dy);
}

// Die Funktion mousePressed() ruft Processing automatisch auf, 
// sobald eine Maustaste gedrueckt wird
void mousePressed(){
// aktueller Inhalt des Programmfensters wird als Pixelbild gespeichert
save(„Stern.png“);
}

Ich fand das ziemlich cool, also hab‘ ich mir Processing kurzerhand runtergeladen und das Teil abgetippt. Hinterher hab Ich den Code auseinandergenommen um zu sehen was passiert wenn hier und da was fehlt oder ich Codezeilen einfach vertausche. Und von da an war ich ein Fan dieser Programmiersprache – bis heute. Und ich sage jeder kann sich Processing aneignen. Du tippst etwas, führst es aus und siehst was du gemacht hast. Sofort und auf der Stelle. Natürlich gibt es gewisse Regeln die zu beachten sind wie beispielsweise die Notation, hinter jede Zeile ein Semikolon etc.. aber Processing unterstützt dich dabei. Wenn du im Code einen Fehler hast, weist dich Processing darauf hin, hebt die betreffende Zeile farblich hervor und gibt unten an, was du falsch gemacht hast. Zum Beispiel ein Argument zuviel an eine Funktion übergeben oder versucht, eine Kommazahl einer int-Variable zuzuweisen. Processing führt dich zu der Zeile und schreibt dazu, was der Fehler ist, du korrigierst es und schon klappt es wieder. Processing lässt gar nicht erst zu, dass dein Programm ausgeführt wird und dann erst im Nachhinein mit einem Fehler wieder abbricht. Ausnahmen sind sogenannte Laufzeitfehler, zum Beispiel wenn du mit mouseX oder mouseY herumspielst und versehentlich versucht wird, durch Null zu dividieren oder wenn Processing feststellt, dass eine Schleife unendlich läuft.

Okay, ich will mir Processing zumindest mal anschauen. Aber was, wenn ich nicht weiterkomme? Wer hilft mir, gibt es gute Anlaufstellen?
Klar gibt es Anlaufstellen. Es gibt die Learning-Section, ein Wiki und das wichtigste, die Referenz (alles auf Englisch, aber das stellt sicher kein Problem dar). Zudem sind in der Processing IDE (also dem Programm selbst) über das Menü „File->Examples“ noch etliche Beispielsketche zu finden. Es gibt ein Forum (auf Englisch) und im Internet auch noch einige Tutorials, jedoch nicht ganz so viele auf Deutsch. Und zu guter Letzt gibt’s ja immer noch meine Seite hier, auf der du Schritt für Schritt von Anfang an an Processing herangeführt wirst 🙂 Ganz hilflos bist du also nicht. Mit meinen Tutorials bist du jedoch an meinen Wissensstand gebunden, du wächst sozusagen mit mir.

Okay, hast du zum Schluss noch einen Tipp für mich, wie ich jetzt am besten loslege?
Sicher =) Zuerst musst du dir Processing natürlich runterladen, das kannst du hier machen. Wie du Processing installierst habe Ich in diesem Artikel beschrieben. Danach geht’s dann los mit der Programmierung, auch dazu gibt’s hier einen Artikel von mir, in dem du alles nachlesen kannst.
Und wenn du das hast, geht es daran dir die wichtigsten Befehle in der Processing Referenz zusammenzusuchen. Begleitend dazu findest du in meinen Artikeln jeweils Links und Verweise für bestimmte Befehle, mit denen du direkt zur Referenz für die jeweilige Funktion gelangst. Zuerst -und das ist das wichtigste- solltest du das Koordinatensystem verstehen, danach dann die einfachen Standard-Befehle für Fenstergröße, Anti-Aliasing (smooth()), Strichfarbe, Füllfarbe, Hintergrundfarbe, Formen und vor allem wie void setup() und void draw() arbeiten. Direkt im Anschluss lernst du Variablen kennen, und spätestens dann bist du ohnehin schon mittendrin in Processing und wirst bis dahin bereits mehr als überzeugt, ja ich denke geradezu begeistert sein von dieser Programmiersprache.

Aber jetzt lad‘ dir Processing erstmal runter, wühl‘ dich durch meine Artikel und lass dich davon faszinieren wie überraschend schnell du zu tollen Ergebnissen kommst 🙂

Bis dahin
Marius

Kommentar hinterlassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Ich stimme zu.

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.