diff --git a/doc/cclass-thoughts.c b/doc/cclass-thoughts.c
new file mode 100644
index 0000000..3f375c4
--- /dev/null
+++ b/doc/cclass-thoughts.c
@@ -0,0 +1,98 @@
+/*
+ * Was wir unter C tun müssen ist separate definition von Interface und
+ * und Daten sowie Methoden....das Interface ist dabei immer verantwortlich
+ * dafür die zur Klasse gehörende Implementation einer Methode aufzurufen.
+ *
+ * In anderen Worten... eine Klasse ist eine konkretisierung eines
+ * Interface. Ebenso wie es viele Objekte einer Klasse geben kann, kann es
+ * auch viele Konkretisierungen eines Interfaces geben.
+ *
+ * Alle Klassen die das gleiche Interface konkretisieren reagieren auf
+ * die gleichen Messages und Objekte dieser Klassen sind daher grundsätzlich
+ * austauschbar.
+ *
+ * Ein Interface kann ebenso wie Klassen andere Interfaces erweitern.
+ * Objekte von Klassen die ein solches erweitertes Interface konkretisieren
+ * koennen auch überall dort eingesetzt werden wo Objekte des Basisinterface
+ * eingesetzt wurden.
+ *
+ * Alles Interfaces müssen wenigstens von dem Basisinterface struct _CCLASS
+ * abgeleitet sein, welches __construct und __destruct sowie class detection
+ * Magic und die Klassengroesse enthält.
+ *
+ * Die Interfaces können zur compilezeit statisch initialisiert werden da
+ * sie sich zur laufzeit nie ändern.
+ *
+ * Über die implementierung multipler interfaces muss ich noch nachdenken.
+ * Denkbar waere den Interfaces reservierte namen zu geben über die dann immer
+ * auf sie zugegriffen werden muss...hat eine Interfacedefinition dann ein
+ * memder dieses reservierten namens hat er auch das Interface.
+ *
+ * === was folgt ist noch nicht in unten stehendem pseudo code ===
+ * 
+ * Die interfaces sollten sich evtl nicht extenden....stattdessen
+ * sollte die Klassenimplementation ihr interface mit den existierenden
+ * Interface definitionen und ihren implementationen initialisieren.
+ *
+ * Das soll heissen zu jeder Klasse (A) wird auch eine Interfaces structur
+ * angelegt die dann konkrete Interface Instanzen initialisiert und mit
+ * einem unique name versieht.
+ *
+ * Dabei ist dann verprflichtend das zumindest das CCLASS interface
+ * eingebunden wird, damit es wirklich eine Klasse wird. :)
+ */
+
+// === INTERFACE DEFINITION =======
+
+typedef void (*fptr_draw)(void *);
+
+typedef struct __SHAPE {
+	struct _CCLASS cclass;
+	struct {
+		fptr_draw draw;
+	} shape;
+} * __SHAPE_PTR;
+
+struct _SHAPE;
+typedef struct _SHAPE * SHAPE;
+
+// === INTERFACE IMPLEMENTIERUNG (for dynamic binding) =======
+
+void * draw(const __SHAPE_PTR shape)
+{
+	const __SHAPE_PTR class = _object - sizeof(void *);
+
+	if (shape && class && class->draw) {
+		class->draw(shape);
+	}
+}
+
+// === KLASSEN IMPLEMENTATION ========
+
+static void draw(CIRCLE * this);
+
+static
+const
+struct __SHAPE _circle = {
+	{
+		CCLASS_MAGIC;
+		sizeof(struct __SHAPE);
+		__construct;
+		NULL;
+		__destruct;
+		NULL;
+		NULL;
+	};
+	{
+		draw;
+	}
+};
+
+static
+void
+draw(CIRCLE * this)
+{
+	/* draw the shape */
+}
+
+// vim: set ts=4 sw=4: