(click the pix.) Im Januar 2009 führte ich einige Experimente mit meiner neu erworbenen CNC-Fräse durch. Eine CNC-Fräse ist eine normale Fräse (in diesem Fall eine Oberkopfportalfräse), die allerdings nicht manuell, sondern von einem Computer gesteuert wird. (pix_1)

Bei meinen ersten Versuchen wurden Löcher gebohrt, Quadrate geschnitten und einfache Schriftzüge graviert. Recht schnell wurde allerdings klar, dass der Ansatz existierender CAD- (zum Entwerfen von Objekten) und CAM-Software (zur Umwandlung des Entwurfs zu einer Folge von Maschinenbefehlen, die die Fräse ausführen kann) nicht wirklich meinem Umgang mit Technik entsprach, weil sie entweder vom Workflow sehr limitiert waren (keine Skriptmöglichkeiten z.B.) oder so hochprofessionell, dass die Einarbeitungszeit eher einem Maschinenbaustudium entsprach. In solchen Fällen zögere ich nie lange, und so beschloss ich, meine eigene CAD- und CAM-Software zu schreiben, am besten noch in Common Lisp, einer recht obskuren und sagenumwobenen Sprache ( http://de.wikipedia.org/wiki/Common_Lisp ). Eine (intensive) Woche später war diese Software in einem brauchbaren Zustand (zu bewundern auf http://cl-mill.googlecode.com/ , der Programmcode ist nur unter dem Einfluss von mittelstarken Alkoholika zu ertragen), samt Bitmaptracing, Kurvenoffsetberechnung, Jobmanagement und Platinenlayoutimport. (pix_2)

Das erste eigentliche CNC-Projekt für diese Software war das Fräsen einzelner Holzbretter, auf die eine USB-MIDI-Kontroller Entwicklungsplatine fixiert werden sollte. Der riesige Vorteil bei dem Einsatz von »offener« Software (in dem Sinne, dass der Programmquellcode erstens erhältlich ist, und zweitens auch malleabel, also einfach genug zu modifizieren und erweitern) ist, dass dadurch generative Ansätze möglich werden. Z.B. der Ansatz, jedes Holzbrett für jede einzelne Entwicklungsplatine anders zu gestalten und zu fräsen, ohne dass der Aufwand für den Entwickler/Designer/Maschinenoperator besonders wächst. Bei diesem konkreten Projekt werden auf der Oberseite jedes Brettes drei tanzende Männchen gefräst, so dass aus jedem einzelnen Board ein Unikat wurde. (pix_3)

Zum Ausprobieren von grafischen und generativen Ideen ist die Processing-Umgebung, die unter http://processing.org/ zu finden ist, nahezu ideal. Ähnlich zu den BASIC-Interpretern (http://de.wikipedia.org/wiki/BASIC) auf früheren Heimcomputern, oder zu der LOGO-Schildkröte (http://de.wikipedia.org/wiki/Logo_(Programmiersprache), bietet Processing die ideale Spielwiese für kleine Programmschnipsel und eine sehr inspirierende Lernumgebung. Die tanzenden Männchen sollten von einem Processing-Programm erzeugt werden, um anschließend von der CAM-Software zu einem Brett zusammengestellt werden. Jedes Monster besitzt zwei Arme, einen Körper und zwei Augen. Um jedes Monster anders zu gestalten, müssen diese Elemente verändert werden. Für die Augen bieten sich Ellipsen an, deren Position und Form variiert wird. Für den Körper und die Arme werden Bézier-Kurven eingesetzt (diese Kurven werden von zwei Anfangspunkten und zwei Kontrollpunkten bestimmt, die interessante Krümmungen erzeugen). Es müssen also die Anfangspunkte und Kontrollpunkte von drei Bézier-Kurven berechnet werden, sowie die Position und Form von zwei Ellipsen. Insgesamt also 32 verschiedene Zahlen, die natürlich nicht komplett zufällig sein dürfen. Der linke Kontrollpunkt des Körpers z.B. befindet sich auf einer Gerade, die im Winkel von 60 bis 90 Grad zur Horizontale steht. Je kleiner der Winkel, desto spitzer die linke Seite des Männchens. Mit ähnlichen Überlegungen wurde die Formeln für die restlichen Glieder erzeugt. (pix_Quellcode + pix_4)

Der erste Versuch sah dann ungefähr so aus: http://bl0rg.net/~manuel/yay-mon/maennchen.pde (code), http://bl0rg.net/~manuel/yay-mon/ (applet). Ganz optimal ist das Programm noch nicht, erlaubt aber die Visualisierung und die Anpassung der Generierungsparameter. Im nächsten Ansatz wird noch die Dicke der Arme und Augen durch einen breiteren Pinsel kontrolliert, und zum Spaß werden ganz viele Männchen zu einer jubelnden Menge zusammengestellt: http://bl0rg.net/~manuel/abspack-crowd/maennchen.pde http://bl0rg.net/~manuel/abspack-crowd/maennchenclass.pde (code) http://bl0rg.net/~manuel/abspack-crowd/ (applet). So wie eine Bleistiftskizze, sind bei dem Programmcode hier die Entstehungsschritte und Radierungen und Ergänzungen sichtbar. (pix_5)

Nach dem Erfolg dieser virtuellen Experimente mit Processing war es nur noch ein schnelles Schieben von Bits und Bytes, bis die CNC-Fräse dank Schrittmotoren die Brücke zwischen virtueller und harter Welt herstellen konnte. (pix_6 + pix_7)

interview part I | II
wesen sounzzz
ruin&wesen

english version
January 2009 was a month of experimentation with my newly acquired CNC mill. A CNC mill is like a normal mill, except that the position of the milling head (or the piece of material, depending on the mill design) is controlled by a computer. (pix_1)

My first tests were of course drilling holes, milling out squares and engraving simple texts and designs. I quickly became aware that conventional approaches to CAD (designing objects) and CAM (converting the design into a sequence of machining steps) did not really suit my development style: either they were quite limited workflow-wise (no scripting for example, which is something I swear by), or highly specialized (and expensive) pieces of professional software requiring a degree in engineering. In cases like these, I usually don’t hesitate long and reinvent the wheel by writing my own software (don’t try this at home, of course). In this case, I wrote a »programmable« environment for generating G-Code (the machine language telling the mill how to move its head). The software was written in Common Lisp, a quite obscure and very expressive language, that in my hands usually ends up in writing chaotic software. A (very intense) week later, I had written a pretty functional software (which you can get at http://cl-mill.googlecode.com, the sourcecode kind of reflects the way it was written though). It features bitmap tracing, offset milling curves, job management and importing PCB-layout files. (pix_2)

The first »real« project for the whole CNC contraption was milling small wooden boards to help mount prototype PCBs for a USB-MIDI-Controller. The biggest advantage of having an »open« program (in the sense that you can get, modify and extend the sourcecode) is that it is easy to use generative approaches (in which part of the design is actually created by an algorithm). The idea for the prototype controller was to have a different wooden board for each PCB, without increasing the design and production workload too much. In this project, I came up with the idea to have dancing people on top of the board. Each board would have a few different creatures on top. (pix_3)

A very nice software to try out graphical and generative ideas is the Processing-environment, that can be downloaded at http://processing.org/ . It is similar to older BASIC-interpreters that would run on older homecomputers, or to the LOGO programming language (yes, the turtle). Processing gives you an ideal playground to try out small »sketches« of software, and provides for rapid feedback: enter the code, press run, modify the code, press run again, etc… The small dancing creatures are generated by a processing sketch, and are converted by the CNC software to actually make a wooden board (with holes for screws, a logo and a serial number). Each creature has two arms, a body and two eyes. To make each creature unique, these elements have to be varied in size and shape (that is, the parameters controlling the geometrical objects behind these elements have to be varied). The eyes are made out of two ellipses, of which the size and position can be modified (however, the ellipse itself is restricted to a certain area of the body, so that one eye doesn’t up on the arms of the creature, or outside its head). The body and the arms are made out of bezier splines (bezier splines are controlled by a starting point, an end point, and two control points that determine their curvature). Thus, we need to generate 8 control values for each spline, and 4 values for each eye. The whole creature is thus described by 32 values that are in specific relations to each other. For example, the first control point of the body spline is situated at a 60 to 90 degree angle left-upward from the starting point. Similar thinking hides behind the calculations for the other parameters of the creature. (pix_Quellcode + pix_4)

The first tries at generating a creature can be seen in the black image above. http://bl0rg.net/~manuel/yay-mon/maennchen.pde (code), http://bl0rg.net/~manuel/yay-mon/ (applet) The program is not yet quite finished: the shape of the creature makes it impossible to mill. However it is quite useful to see which parameters need to be adjusted. In the next try, the width of the arms was made bigger, and a lot of creatures were put together to create a dancing crowd. http://bl0rg.net/~manuel/abspack-crowd/maennchen.pde http://bl0rg.net/~manuel/abspack-crowd/maennchenclass.pde (code) http://bl0rg.net/~manuel/abspack-crowd/ (applet) As with a pencil sketch, the code shows the different steps of its creation. (pix_5)

Declaring this second test a success, it was just a matter of writing a few more program lines to convert the image of the creatures to G-Code that would be interpreted by the CNC mill, linking the real world to a digital idea. (pix_6 + pix_7)

wesen sounzzz
ruin&wesen

happy crowd

Die praktische Anwendung der Programmierung mit Processing.

»Es ist meins, es macht Spaß, es macht Sinn.«

Endlich und nur hier. Part II des Interviews mit Manuel Odendahl, Minimal Techno DJ, Softwareentwickler und Gründer von Ruin&Wesen. Location: Technologie Park Karlsruhe, irgendwann Ende dieses Sommers. Um was es geht: Microcontrolling, Midi Command, Sounzzz und schlaflose Nächte.

Nun lebt und arbeitet Wesen in Weimar und macht Dinge, von denen wir bald mehr sehen und noch mehr hören werden. Respect2U. Location: Gaswerk.

Interview Manuel Odendahl Part I.

»Ich fokussiere kleine Einheiten – beim Programmieren machen schon zwei Zeilen richtig viel aus.«

Manuel Odendahl war keine zehn Jahre alt, als er begann, sich für Computer zu begeistern. Der Auslöser, mit dem Programmieren anzufangen, war dann ein kleines Heft mit der Programmieranleitung für ein Abenteuerspiel.

Inzwischen kann er auf eine Programmiererfahrung von über zwölf Jahren zurückblicken, von denen er mehr als zehn Jahre bis zu 12 Stunden täglich vor dem Rechner verbrachte. Direkt nach der Schulzeit kamen parallel zum Informatikstudium die ersten Programmierjobs. Heute vereint Manuel Odendahl seine Leidenschaft für neue Anwendungen und Lösungen mit ausgiebiger Fachkenntnis und jeder Menge Erfahrung.

»Mir kommt das, was ich jetzt mache, oft sehr einfach vor. Ich bin sehr froh, dass ich schon so früh damit angefangen habe. Heute könnte ich gar nicht mehr nachholen, was ich alles schon gemacht und gelernt habe.«

Vor etwas vier Jahren begann er, sich zusätzlich intensiv mit Musik zu beschäftigen. Von seinem Bass schwenkte er zur elektronischen Musik. An Techno fasziniert ihn dabei die Nähe zum Programmieren und das direkte Feedback bei seinen Live-Gigs: »Ich messe mich gerne. Und bei Techno ist das ganz einfach. Wenn Du nicht gut bist, ist schnell keiner mehr da.«

Für einen seiner Live-Gigs entwickelte, programmierte und baute er dann auch vor ca. einem Jahr seinen ersten MIDI Controller, um die Soundmöglichkeiten seiner Drum Machine zu erweitern. Schnell entwickelte sich eine rege Nachfrage auch von anderen Musikern. Inzwischen hat sich Manuel Odendahl mit seiner eigenen Firma Ruin&Wesen konsequent auf die Entwicklung und Programmierung von MIDI Controllern spezialisiert. Zahlreiche Möglichkeiten, die Ruin&Wesen Controller selbst für bestimmte Zwecke zu programmieren, finden sich als Open Source auf seiner Homepage.

»Was ich beim Musik machen lerne und merke, kann ich auch wieder auf die Entwicklung der Controller anwenden. Es sind insbesondere immer die kleinen Dinge – Feinheiten, die den Unterschied ausmachen.«

Sein umfangreiches Wissen gibt Manuel Odendahl außerdem in dem bei O’Reilly erschienenen Buch Arduino – Physical Computing für Bastler, Designer und Geeks weiter. Daneben bastelt Manuel Odendahl weiter fleißig eigene Sounds, setzt konsequent eine nach der anderen neuen Idee um und ist zusätzlich immer wieder auch bei Live-Gigs zu sehen.

Wir freuen uns, Volker Bombien mit seinem ersten Artikel als Gastautor in der Inspiration Lounge zu begrüßen:

Ich beschäftige mich in diesem Beitrag mit der Frage, welche Faktoren dafür ausschlaggebend waren, dass Twitter so erfolgreich wurde.

1. Twitter ging von Beginn (2006) mit einer offenen Schnittstelle an den Start. Diese so genannte API (Application Programming Interface) erlaubt es, alle Tweets aller Twitterer abzufischen und in andere Dienste zu integrieren.

2. Dies führte zu der Ausbildung einer ausgeprägten Kernel-/Plugin-Architektur, DAS Wachstumsmodell von moderenen Open-Source-Projekten wie Linux, Firefox oder Nagios. Die Twitter-Kernanwendung wurde schon bald von einer schier unüberschaubaren Zusatzdienste umrahmt.

3. Dadurch wurde Twitter extrem anwendungsflexibel – ein Dienst für viele unterschiedliche User-Bedürfnisse. War Twitter von seinen Entwicklern anfänglich wirklich gedacht als eine Online-Anwendung, die Freunde untereinander darüber informierte: »What are you doing«, so wurden die Anwendungszwecke durch Zusatzdienste täglich erweitert.

4. Es hört sich paradox an, aber gerade die Abwesenheit eines erfolgversprechenden Business-Modells ermöglichte Twitter erst die Flexibilität, sich zu dem zu entwickeln, was es heute ist.

5. Der Twitter-Account ist kostenlos und innerhalb weniger Minuten ohne jedes technische Vorwissen selbst erstellt. Die Twitter-Mitgliedschaft verpflichtet zu nichts und kann jederzeit vom User gekündigt werden.

6. Es wird keinerlei (kultur-)technisches Vorwissen benötigt, um zu twittern. Es gibt kein richtiges und kein falsches Twittern und keine Instanz, die festlegt, was korrekt oder was verpönt ist. Vorerfahrungen in anderen Online-Kulturtechniken wie Bloggen o.ä. sind keine notwendigen Qualifikationen fürs Twittern; jeder kann auf den Zug aufspringen.

7. Twitter kann von vielen Geräten aus empfangen und bedient werden: PC, Handy, Smartphone, Netbook. Die Beschränkung auf 140 Zeichen ermöglicht die erträgliche Darstellung auch auf mobilen Geräten. Ein Tweet ist auch schnell von unterwegs geschrieben, ein Foto leicht gemacht und als Link getwittert.

8. Menschen müssen das unübersichtliche Internet nach für sie relevanten Inhalten filtern. Freunde stellen dabei einen sehr effektiven, vertrauenswürdigen Filter dar. Was der Freund (die Institution/die Firma) für interessant hält, ist auch für mich interessant.

9. Twitter kann ohne großen zusätzlichen Zeitaufwand in den beruflichen und privaten Online-Alltag integriert werden. Das asynchrone Kommunikationsmedium Twitter erlaubt jederzeit einen temporären Ausstieg aus dem Lesen des Tweet-Stromes; wenn wieder mehr Zeit vorhanden ist, widmet man sich intensiver um seine Tweets.

10. Bin ich bei Twitter Alltagsjournalist oder Leser solcher Tweets? Bin ich Konsument von Nachrichten – oder Produzent? Empfehle ich dieses Restaurant oder folge ich der Empfehlung eines Twitterers? Kommentiere ich meinen Alltag dokumentaristisch oder erfreue ich mich an den originellen Kommentar-Tweets anderer? Das Verschwimmen der Sender-/Rezipienten-Grenzen macht schwindelig – ein schönes Gefühl.

11. In Twitter wird vieles quantifizierbar: wie viele Followers, wie viele Followings? Wie viele Tweets empfangen, wie viele verschickt? Wie viele Resonanz durch Retweeten? Das vielfältige Quantifizieren erleichtert das Erlernen einer recht frischen, neuen Kulturtechnik: soziale Beziehungen online auf- bzw. ausbauen und pflegen.

(volker bombien)

Anm. der Redaktion:
Punkt 4. ist mal wieder ein schönes Beispiel dafür, dass es offensichtlich immer wieder Menschen gibt, die es nicht so machen, wie es nach gängigen Business-Ratgebern gemacht werden muss – und die, man höre und staune, trotzdem oder gerade deshalb etwas auf die Beine stellen.