Yesterday the first decoded conference took place in Munich. There were five speeches that related to the interplay of design and code. The speakers were

1. Benedikt Groß and Hartmut Bonacker, the authors of the book Generative Gestaltung
2. Mario Klingemann, who calls himself a “computational artisan”
3. Moritz Stefaner, who creates beautiful information visualizations
4. Tilman Reiff and Volker Morawe aka //////////fur////, two guys who create incredible gaming machines
5. Massiomo Banzi, co- founder of arduino and chief technical officer of tinker.it

The speech of Benedikt and Hartmut was focused on generative design. They talked about the principles of generative design and the associated shift in the design process.

The incredible Mario Klingemann showed some of the methods and tools which he uses in his works (delaunay triangulation, voronoi diagram, etc). His ActionSpript library quasimondolibs is available at google code.

Moritz Stefaner talked about information visualization and some of his projects like wellformed.eigenfactor and X by Y.

When the guys from //////////fur//// entered the stage, the focus switched from generative art to … well, let’s call it physical computing. They create beautiful gaming machines that are hard to describe:

Last but not least Massimo Banzi talked about arduino and the do-it-yourself community. He called the audience up to build their own products instead of just consuming what the industry serves.

All speakers gave an insight into their working process and the thoughts behind their work. Every speaker showed at least one project where circles were placed randomly on a canvas without overlapping each other, so it seams that this is the most important technique in the generative design field.

Here are some of the speaker’s favorite projects, that they showed yesterday:

The first decoded conference was a beautiful and inspiring event. I am looking forward to see the decoded conference in 2011 again.

In this post I will explain how to invoke superclass constructors and how to override superclass methods. Let’s start with the superclass constructor:

package
{
	public class ParentClass
	{
		public function ParentClass():void
		{
			trace("Constructor of ParentClass executed");
		}
	}
}

package
{
	public class ChildClass extends ParentClass
	{
		public function ChildClass():void
		{
			super();
		}
	}
}

This is a very easy example. In fact you do not even have to call the super() statement in ChildClass. If you do not explicitly call it, a call with no arguments is automatically inserted before the first statement in the subclass constructor body.

Superclass constructor with arguments

If your superclass constructor takes one or more arguments, you must explicitly call the superclass constructor with the correct number of arguments. If you do not call the superclass, the following error occures: 1203: No default constructor found in base class ParentClass.

package
{
	public class ParentClass
	{
		public function ParentClass(a:String):void
		{
			trace("Constructor of ParentClass executed");
		}
	}
}

package
{
	public class ChildClass extends ParentClass
	{
		public function ChildClass(a:String):void
		{
			super(a);
		}
	}
}

Calling methods of a superclass

So how can you call any method of your superclass? First of all, your method should not be private, because private functions are not accessible in subclasses. If the method does not have to be public, it is a good idea to make it protected.

package
{
	public class ParentClass
	{
		public function ParentClass(a:String):void
		{
			trace("Constructor of ParentClass executed");
		}
 
		protected function MyMethod():void
		{
			trace("MyMethod executed");
		}
	}
}

package
{
	public class ChildClass extends ParentClass
	{
		public function ChildClass(a:String):void
		{
			super(a);
			super.MyMethod();
		}
}

Overriding superclass methods

You can override superclass methods in your subclass:

package
{
	public class ChildClass extends ParentClass
	{
		public function ChildClass(a:String):void
		{
			super(a);
			super.MyMethod();
		}
 
		override protected function MyMethod():void
		{
			trace("Overriden MyMethod executed");
		}
	}
}

Add additional behaviour to a superclass method

Sometimes you want to invoke a superclass method, but want to add additional behaviour to it. You can do this by overriding the method and in the first statement of your overriding function call the superclass method. After this statement you can add additionl behaviour:

package
{
	public class ParentClass
	{
		public function ParentClass(a:String):void
		{
			trace("Constructor of ParentClass executed");
			MyMethod();
		}
 
		protected function MyMethod():void
		{
			trace("MyMethod executed");
		}
	}
}

package
{
	public class ChildClass extends ParentClass
	{
		public function ChildClass(a:String):void
		{
			super(a);
		}
 
		override protected function MyMethod():void
		{
			super.MyMethod();
			trace("Overriden MyMethod executed");
		}
	}
}

Recently I designed a news app for the iPhone at work. Sadly I have to work on a Windows PC and I could not find an easy way to make a good prototype for the iPhone on Windows. But fortunatelly I have my good old MacBook Pro at home. I found a very usefull prototyping application created by Nicholas Zambetti called LiveView.

LiveView has two parts: A screencaster application for your Mac and the iPhone app. The system allows you to transfer a part of your computer screen to your iPhone.

You can create a prototype in your prefered prototyping application (for example Flash), run this protoype on your computer and transfer the computer screen to the iPhone. It is even possible to use your iPhone touchscreen to interact with the prototype.

function splice(startIndex:int, deleteCount:uint, ... values):Array

startIndex: The first item to be removed
deleteCount: The number of items to be removed
values: is optional and allows you to insert new items into the array.

So let’s say we want to remove a specific item from our array but don’t know the items position inside the array:

var objectToBeRemoved:Sprite = new Sprite();
var myArray:Array = new Array();
myArray.push(objectToBeRemoved);
 
// Remove item from myArray
myArray.splice(myArray.indexOf(objectToBeRemoved), 1);

This video is so beautiful. Seen on generator.x. You can find more of Brandon Morses art on his website coplanar.org.

Flow is a visual workflow manager for design projects. It is a little bit like a version control system for designers. Flow visualizes dependencies of files and helps you to handle different versions of a file.
The interface of this beautful software was created by Mark Coleran, who is well known for his fantasy user interfaces for films like Bourne Ultimatum and Tomb Rider.

PAGE, one of the most popular design magazines in Germany, published an article about my project Das Astronomische Jahr. In their new magazine “weave” they published the article “Generation Interactive”, in which Jens Franke gives an overview of current trends in interaction design. He presents some interesting student projects, among others my 6th semester project “Das Astronomische Jahr”:

For their project “Das Astronomische Jahr”, Paul Wortberg, David Jacobsen and Benedikt Weiß from the Hochschule für Gestaltung Schwäbisch Gmünd turned ordinary input devices – a mouse and a PowerMate-knob from Griffin Technology – into a intuitive Interface: The circular projection area is mounted on a ball bearing, the underlying knob detects velocity and directon of rotation and passes it as keyboard signals to a flash application. … It is appearent, that the sophisticated design of the interface replaces a classical interface control. Interface designers can so focus on the design of the content and don’t have to think about buttons et cetera.

This video of the Microsoft Office Labs shows Microsoft’s vision of how we will interact with computers in the year 2019.

I particularly like:
• The idea of the interactive board as window to other classrooms
• The ePaper boarding pass
• The guidance system at the airport (is this a cellphone?)
• The keychain
• The gesture based interactions, especially the data transfer between the devices
• The visual appearance of the interfaces. It looks as though it were printed on paper, not like a screen (and definitely not like Windows Vista)