programmieren « WordPress.com Tag Feed

Pixelmanipulation in C++ mit openFrameworks

netzwelten — Mon, 30 Nov 2009 20:18:12 +0000

Grundsätzlich eignet sich C++ mit den openFrameworks-Bibliotheken wunderbar, um Pixel von Bildern auszulesen oder zu manipulieren.

Das geht wie folgt:


ofImage picture;
picture.loadImage("name_of_picture.xxx");
unsigned char *pixels = picture.getPixels();

Jetzt hat man alle Pixel, jeweils mit den drei RGB Farbwerten in pixels, z.b. pixels[0] = (255,255,255). Diese kann man jetzt mit zwei Schleifen zeilen- und spaltenweise durchlaufen, man muss lediglich darauf achten, dass immer drei hintereinanderliegende Werte eine Farbe definieren (RGB). Das könnte wie folgt aussehen:


for (int i = 0; i < picture.height * 3; i ++)
    {
        for (int j = 0; j < picture.width * 3; j ++)
        {
            for (int k = 0; k < 3; k++)
            {
                z = pixels[i * picture.width + j + k];   // z is now a value between 0 and 255
                // Do something with z
            }
        }
    }

Was kann man nun damit anfangen? Meine Kreativität hat jetzt dazu gereicht, ein kleines Programm zu schreiben, dass die Farbe jedes Pixels ausliest und eine HTML-Datei erstellt, die pro Pixel den Buchstaben “a” in der jeweiligen RGB-Codierung enthält. Leider wird so eine HTML-Datei bei einem 5 Megapixel zig Megabyte groß, was dem Firefox nicht wirklich gut bekommt. Also Bild runterskaliert und nur jeden dritten Pixel beachten.

Dann wird aus: (640×480 Pixel)

diese vom Programm generierte, knapp 10 Megabyte große HTML Datei: (Strg+ lässt das Bild schrumpfen, die Markierung der “a”s soll zeigen, dass es sich um Text handel)

Hier noch das ganze Programm, inklusive einer Funktion zur Kreierung des Hex-RGB-Wertes für das HTML font-Tag:


#include "testApp.h"
#include "stdio.h"
#include <fstream>

ofImage picture;
fstream output;

string int2hex(int decimal)
{
        if (decimal == 0)
        {
            return "00";
        }

        string hex = "";
        int tmp;

        for (int i = 0; i <= 2 * sizeof(int) - 1; i++)
        {
          tmp = decimal >> i*4;
          if (tmp == 0)
            break;
                hex = "0123456789ABCDEF"[(tmp & 0xF)] + hex;
        }

        if (hex.length() == 1) {
            hex = "0" + hex;
        }

        return hex;
}

//--------------------------------------------------------------

void testApp::setup(){

    string color = "";
    picture.loadImage("coffee.jpg");
    output.open("output.html", ios::out);
    int z = 0;
    unsigned char *pixels = picture.getPixels();

    output << "<html><body><small><small><small>" << endl;

    for (int i = 0; i < picture.height * 3; i += 3)
    {
        output << "<nobr><code>" << endl;
        for (int j = 0; j < picture.width * 3; j += 3)
        {
            color = "";
            for (int k = 0; k < 3; k++)
            {
                z = pixels[i * picture.width + j + k];
                color += int2hex(z);
            }

            output << "<font color=\"#" << color << "\">a</font>" << endl;

        }

        output << "</code><\/nobr>" << endl;
        output << "<br>" << endl;

    }

    output << "<\/small><\/small><\/small><\/body><\/html>" << endl;

    output.close();
}

Conway's Game of Life in C++ (openFrameworks)

netzwelten — Sun, 29 Nov 2009 09:20:58 +0000

Homepage moved to: www.netzwelten.net

Conway’s Game of Life in C++ (openFrameworks)

Es kann YouTube

nkreipke — Wed, 25 Nov 2009 21:25:43 +0000

TubeFlect kann ab heute doch tatsächlich schon mal das Grundlegende, was es können muss: YouTube-Videos abspielen. Das soll vorerst nur als Test laufen, weshalb das Layout auch noch nicht perfekt aussieht. Wie es funktioniert: Man nehme einen handelsüblichen YouTube-Link, kopiere ihn in das Textfeld und klickt auf “Load Video”. TubeFlect schnappt sich daraufhin den Flashplayer aus der YouTube-Seite und lädt ihn im Fenster. Das beste daran: Da er die Elemente rund um den Flash-Player nicht laden muss, geht der Ladeprozess schneller als auf konventionelle Methode – ein Pluspunkt für Leute mit schwachen Internetleitungen.

Somit haben wir schon mal einen Grundstein gelegt für eines der Prioritäten von TubeFlect: Das schnelle Laden von Videos. Den Text und vor allen Dingen die Werbung drumherum, die immer zuerst geladen werden, werden jetzt elegant übersprungen.

Zum ersten Mal kann man jetzt schon die Grundidee von TubeFlect sehen: Das Video im Mittelpunkt. Wie gesagt, alles erstmal nur ein Test, das Layout des Videobrowsers gefällt uns auch nicht Zum Screenshot: Die YouTube-Suche funktioniert noch nicht, die Buttons in der Menüleiste auch nicht. Die letzten Probleme mit der Navigationsleiste sind behoben, so wird sie vorerst bleiben. Der Vollbildmodus vom VouTube-Video funktioniert selbstverständlich und auch maximieren kann man die Geschichte schon. Die 4 Favoritenordner hab ich mit dem Plusbutton hinzugefügt, das funktioniert also auch schon gut.

Wir haben heute zusätzlich zum Browser auch unter der Haube ein paar Sachen geändert. Der Quelltext ist insgesamt kleiner geworden, es wird nicht mehr durch unnötige Variablen Speicher verbraucht. Auf dem Screenshot seht ihr übrigens FileMerger, ein Hilfsprogramm mit dem man 2 Dateien miteinander vergleichen kann. Rechts ist die alte Version des FolderListControllers, links die neue Version.

Zum Schluss noch 2 Sachen: Erstens sieht man, dass wir wirklich nur träge weiterkommen. Das liegt daran, dass wir täglich wegen dem Schulstress momentan nur maximal 2 Stunden pro Tag Zeit für TubeFlect haben. Außerdem bin ich noch nicht gerade der Profi in Sachen Cocoa-Programmierung und Obi versteht nur Bahnhof vom Quelltext

Außerdem möchte ich demnächst einen zweiten Blog eröffnen, der sich nur um TubeFlect kümmert. Ich möchte diesen Blog weiterhin als Privatblog behandeln und nicht mit Changelogs vollstopfen. Ich sage euch bezüglich der Änderung rechtzeitig bescheid.

Recoding

nkreipke — Tue, 24 Nov 2009 21:32:17 +0000

Wie es der Teufel so wollte, habe ich gemeinsam mit Obi das Grundgerüst von TubeFlect neugeschrieben. Also kompletter Neustart mit neuer, leerer Projektdatei. Durch das Recoding haben wir einige Probleme behoben und solche, die noch kommen sollten, direkt verhindert:

Alle Controls wurden getaggt und ausreichend mit Identifiers versehen.
Copy-Paste ist wieder möglich.
Wir haben direkt mit 2 TableViews angefangen, und so konnten wir das bestehende Problem mit dem Löschen und Editieren der Hauptkategorien beheben.

Ansonsten sind wir eigentlich auf dem Stand von gestern. Dafür gibbet auch noch mal eine größere Auswahl von momentanen Screenshots:

openFrameworks

netzwelten — Sat, 21 Nov 2009 14:30:59 +0000

Heute ist endlich mein über Amazon.de bei einem englischen Händler bestelltes Buch “Programming Interactivity” von Joshua Noble gekommen . Der Untertitel des über 700 Seiten schweren Buches lautet “A Designer’s Guide to Processing, Arduino, and openFrameworks“, also genau das, womit ich mich zur Zeit befasse. Schon beim Stöbern bei Amazon viel mir das äußerst vielversprechende Inhaltsverzeichnis sofort auf.

Aber hier soll es erstmal um die Einrichtung von openFrameworks gehen. Was ist das überhaupt? openframeworks.cc titelt selbst: openFrameworks is an open source C++ toolkit for creative coding. Hört sich schon mal ganz interessant an. Dann wollen wir uns das mal ansehen.

Zuerst benötigen wir einen C++ Compiler für Windows. openFrameworks.cc und “Programming Interactivity” nennen u.a. Code::Blocks (Open Source). Dieser ist schnell runtergeladen (10,8 + 19,3 MB) und installiert. Zusätzlich werden die Code::Blocks Additions für openFrameworks benötigt. Die includes und libs des ZIP-Files kopieren wir nach C:\Program Files (x86)\CodeBlocks\MinGW.

Nun geht es weiter mit dem eigentlichen openFrameworks. Dieses wird von der openFrameworks Downloadseite heruntergeladen. Damit der Compiler die entsprechenden Dateien auch finden und zuordnen kann, sollte der Inhalt des openFrameworks nach C:\Users kopiert werden.

Das wars, nun kann der Spaß beginnen. Am einfachsten beginnt man immer mit dem Leer-Beispiel, was openFrameworks mitliefert. Das würde sich dann in C:\Users\apps\examples\emptyExample befinden. Ordner z.B. auf den Desktop kopieren und emptyExample.cbp starten (im Regelfall sollte diese Dateiendung dann mit Code::Blocks verknüpft sein). Im Programm werden wir hauptsächlich in der TestApp.cpp programmieren:

Wir sehen verschiedene Funktionen. setup() ist vergleichbar mit der setup() aus Processing oder der Arduino-Umgebung. update() wird vor draw() aufgerufen – draw() ist die Dauerfunktion in openFrameworks, so wie loop() bei Arduino und die gleiche draw() bei Processing. Dann sind noch die häufig benutzten Funktionen zum Abfangen von Tastatur- und Mauseingaben deklariert.

Unser Hallo-Welt-Programm soll einen Kreis darstellen:


#include "testApp.h"
#include "stdio.h"

//--------------------------------------------------------------
testApp::testApp(){

}

//--------------------------------------------------------------
void testApp::setup(){

}

//--------------------------------------------------------------
void testApp::update(){
}

//--------------------------------------------------------------
void testApp::draw(){
    ofSetColor(0,0,0);
    ofFill();
    ofCircle(400,400,200);
}

//--------------------------------------------------------------
void testApp::keyPressed  (int key){
}

//--------------------------------------------------------------
void testApp::keyReleased(int key){

}

//--------------------------------------------------------------
void testApp::mouseMoved(int x, int y ){
}

//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){
}

//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){

}
//--------------------------------------------------------------
void testApp::mouseReleased(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::resized(int w, int h){

}

Das Ergebnis ist eine 1.226kb große EXE-Datei, die dieses Ergebnis ausgibt:

Buch-Rezension zu "Systemarchitekturen für Verteilte Anwendungen"

Johnny Graber — Thu, 19 Nov 2009 19:30:21 +0000

Die steigenden Anforderungen an aktuelle Software benötigen entsprechend flexible Lösungen. Herausforderungen wie Skalierbarkeit oder Ausfallsicherheit hofft man mit verteilten Systemen lösen zu können. Doch wo soll man starten? Was für Möglichkeiten gibt es und wie kann man die unzähligen Begriffe und Konzepte einordnen?

Diese und weitere Fragen versucht das Buch “Systemarchitekturen für Verteilte Anwendungen” von Jürgen Dunkel, Andreas Eberhart, Stefan Fischer, Carsten Kleiner und Arne Koschel zu beantworten. Eine kurze Einführung über Software-Architektur und eine Erklärung der grundlegenden Begriffe dient als Start in die Welt der verteilten Anwendungen.

Diese Konzepte werden im 2. Teil vorgestellt:

Um ein Gefühl dafür zu bekommen wird jeweils eine Erklärung des Architekturkonzepts, eine Übersicht zu den Realisierungsplattformen und Code-Beispiele geliefert.

Teil 3 behandelt die Auswahl einer konkreten Architektur. Die im zweiten Teil vorgestellten Konzepte werden wieder aufgenommen und auf die Anforderungen aus dem Softwarelebenszyklus hin untersucht. Dies umfasst die Problemanalyse, das Design, die Implementierung und Test, sowie den Betrieb und die Wartung.
Die Fallbeispiele aus der Praxis reichen vom LAMP-Stack über den PetStore von Java EE bis hin zum Grid des CERN für den LHC (Large Hadron Collider).

Als Abschluss dient ein Ausblick auf Software as a Service (SaaS), Virtualisierung und Cloud Computing.

Stärken und Schwächen
Ein so komplexes und grosses Thema auf weniger als 300 Seiten näher zu bringen ist eine grosse Herausforderung. Es gelingt den Autoren einem einen guten Überblick zu verschaffen und hilft dabei, die unzähligen Begriffe einordnen zu können. Die Stärken des Buches liegen eindeutig bei den allgemeinen Erklärungen.

Bei den konkreten technischen Umsetzungen fällt die Qualität aber stark ab. Die Code-Beispiele sollen zeigen wie das Beschriebene konkret umgesetzt wird. Allerdings sind diese viel zu kurz und wenn man sich nicht bereits mit dem Thema auseinander gesetzt hat wird man kaum verstehen, was da nun gezeigt wird. Die Seitenlangen XML-Dokumente helfen da auch nicht weiter.

Die Formatierung ist sehr gewöhnungsbedürftig. Alle Leerzeichen in den Strings werden konsequent markiert – auch dann wenn diese nur zum einrücken dienen und über die halbe Seite gehen. Dafür fehlt bei Befehlszeilen der Hinweis, dass der Zeilenumbruch dem Layout geschuldet ist und man den Befehl als eine Zeile eingeben muss.

Auch sehr gewöhnungsbedürftig ist die Art, wie auf weiterführende Literatur verwiesen wird. Als Beispiel die Einleitung des Architekturkonzepts der Grid Architekturen:

Als Geburtsstunde des Grid Computing wird üblicherweise das Jahr 1998 mit dem Erscheinen des Werkes [25] genannt.

Möchte man wissen welches Buch gemeint ist, bleibt einem nichts anderes übrig als zum Literaturverzeichnis zu blättern. Dies ist leider kein Einzelfall.

Die grosse Anzahl der Autoren bemerkt man bei den Erklärungen der Begriffe. Teilweise wird sehr grosszügig damit umgegangen und dann wiederum werden Abgrenzungen gemacht, die mit der Praxis kaum noch etwas zu tun haben.

Die Fallbeispiele sind eine Enttäuschung. Der LHC an sich ist spannend, doch wer braucht eine vergleichbare Lösung? Und ist die Demo-Applikation PetShop wirklich erwähnenswert? Mehr Beispiele aus der Praxis die einer grösseren Leserschaft bekannt sind (wie Amazon) hätten da besser gepasst.

Fazit
Das Buch ist gut geeignet um einen Überblick über das Thema der verteilten Anwendungen zu bekommen. Wer allerdings an der technischen Umsetzung interessiert ist, sollte sich nach einem anderen Buch umschauen.

Zum Buch
Systemarchitekturen für Verteilte Anwendungen, von Jürgen Dunkel, Andreas Eberhart, Stefan Fischer, Carsten Kleiner und Arne Koschel, 2008 HANSER, ISBN 978-3-446-41321-4, 293 Seiten

[Tutorial]TI89Titanium: Programmieren eines Spiels |Teil 2|

ceecilion — Tue, 17 Nov 2009 19:04:14 +0000

Teil 1|-

TEIL 2: Das Grundgerüst

Wir müssen erstmal eine “Oberfläche” Herstellen. Ein Inhaltsloses Programm, das sich immer wieder wiederholt, bis es den Endbefehl vom Benutzer bekommt.Die einfachste Art, das hinzukriegen, ist es zuerst eine Variable für die Tasten zu Definieren und das Programm in einer While-schleife laufen lassen, bis Escape registriert wird. Das sollte dann so aussehen:

Spiel1()
Prgm
o➝key
While key≠264[Escape]
Getkey➝key
Endwhile
Endprgm

Dieses Programm läuft nun in einer endlosschleife, bis wir Escape drücken.
Als vereinfachte Version eines Chars nehmen wir einfach mal einen Kreis. Dazu DEfinieren wir seine Y- und seine X-Position in Variablen und zeichnen ihn.

Spiel2()
Prgm
o➝key
15➝Cy
17➝Cx
While key≠264[Escape]
Getkey➝key
Pxlcircle Cy,Cx,15
Endwhile
Endprgm
nun soll sich unser Char aber auch bewegen können. Da die Tasten schon abgefragt werden, müssen wir also nurnoch die veränderung der Variabeln einsetzen.

Spiel3()
Prgm
o➝key
15➝Cy
17➝Cx
While key≠264[Escape]
Getkey➝key
Pxlcircle Cy,Cx,15
if key=344 then
Cy+5➝Cy
Endif
if key=338 then
Cy-5➝Cy
Endif
if key=340
Cx+5➝Cx
Endif
if key=337 then
Cx-5➝Cx
Endif
Endwhile
Endprgm

Das geht natürlich sehr viel eleganter, aber dazu kommen wir später.
Jetzt bewegt sich unser Kreis zwar, aberer zieht eine Lange Spur hinter sich her. um die Verschwinden zu lassen, reinigen wir einfach den Screen bei jedem Durchlauf.

Spiel4()
Prgm
o➝key
15➝Cy
17➝Cx
While key≠264[Escape]
ClrDraw
Getkey➝key
Pxlcircle Cy,Cx,15
if key=344 then
Cy+5➝Cy
Endif
if key=338 then
Cy-5➝Cy
Endif
if key=340 then
Cx+5➝Cx
Endif
if key=337 then
Cx-5➝Cx
Endif
Endwhile
Endprgm

So. Das Grundgerüst des Spiels steht.
beim nächstem mal behandeln wir die grobere Spielmechanik

Sequel Pro - MySQL Management

Allan — Tue, 17 Nov 2009 17:56:41 +0000

Da war ich wieder mal auf der Suche nach allem und finde ganz was besonderes. Ich hatte schon ein an

Processing-Spielerei

netzwelten — Sat, 14 Nov 2009 20:09:09 +0000

Das Bild im Kopfbereich dieses Blogs ist ja bekannt:

Jetzt habe ich mal an einem kleinen Processing-Sketch gearbeitet, um mir ein neues Bild zu erstellen:


PFont font;
String[] data = new String[40]; // Array of 40 strings
int i = 0;

void setup()
{
  noStroke();
  size(800, 200);
  randomSeed(0);
  int zero_or_one = 0;
  for (int h = 0; h < 39; h++) {
    String zero_one_string = "";
    for (int number = 0; number < 100; number++) {
      zero_or_one = int(random(0,2)); // 0 or 1
      zero_one_string = zero_one_string + str(zero_or_one); // create string of 0s and 1s
    }
    data[h] = zero_one_string; // fill array
  }
  font = loadFont("CourierNewPSMT-48.vlw");
  textFont(font);
  textSize(18);
}

void draw()
{
  fill(255 - i*0.25, 255 - i*0.25, 255 - i*0.25);
  rect(i,0,i,height);
  fill(0,0,120);
  int k = 15;
  for (int lines = 0; lines < height/20; lines++) {
    text(data[lines],lines,k);
    k += 20;
  }
  i++;
  for (int z=0; z<5; z++) {
    fill(155-z*10,224-z*30,220+z*10,18);
    ellipse(0,height/2-height/4+z*4,200,200);
  }
}

Der Sketch erstellt ein paar zufällige Strings aus Nullen und Einsen, stellt sie untereinander dar und lässt Weiß- bis Schwarztöne horizontal darüberlaufen. Heraus kommt das hier:

Das nehme ich jetzt auch erstmal als neues Bild im Kopfbereich.

Arduino²: Zwei Arduinos verbinden

netzwelten — Sat, 14 Nov 2009 12:21:28 +0000

Neue Blog-Url: www.netzwelten.net

Artikel ist hier verfügbar

Arduino im Netz

netzwelten — Thu, 12 Nov 2009 19:10:41 +0000

Heute kam per Post mein bei Watterott.com bestelltes Arduino Shield – Ethernet. Hierbei handelt es sich um ein zusätzliches Shield für den Arduino Duemilanove, das man einfach auf den Arduino steckt. Auf dem Shield befindet sich ein Netzwerkkabelanschluss (RJ45):

Shield also draufgesteckt und erstmal angeschlossen. Dann Arduino.cc – EthernetShield angesehen und die Referenz zur Bibliothek studiert.

Herausgekommen ist ein kleiner Sketch, der dem Arduino die IP 192.168.2.20 im lokalen Netzwerk zuordnet und den Arduino als Server fungieren lässt:


#include <Ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 2, 20 };

Server server(80);

void setup()
{
  Ethernet.begin(mac, ip);
  server.begin();
}

void loop()
{
  Client client = server.available();
  if (client) {
    server.print("Und der Arduino ist im Netz...");
  }
  delay(10);
  client.stop();
}

Bei der Wahl der MAC- und IP-Adresse sollte man darauf achten, keine Konflikte im lokalen Netz zu erzeugen. Also erstmal auf “Upload” gedrückt. Dieser dauert gefühlt ein wenig länger als bei Offline-Sketches.

Arduino pingt jedenfalls schon mal zurück:

Nun mal schauen, ob auch im Browser was zu sehen ist:

Um den Arduino mit der dem Heimnetzwerk von dessen Provider im Internet zugewiesenen IP-Adresse anpingen und -surfen zu können, muss jetzt noch je nach Router ein NAT (=Network Address Translation) eingerichtet werden, so sieht das z.B. beim Telekom-Speedport aus:

Temperatur messen mit Arduino Teil 2

netzwelten — Tue, 10 Nov 2009 20:04:31 +0000

Homepage moved to: www.netzwelten.net

Temperatur messen mit Arduino Teil 2

Arduino: Testen der RGB-LED

netzwelten — Mon, 09 Nov 2009 20:27:18 +0000

Das fleißige Bauelemente-Testen geht weiter. Heute muss die RGB-LED – auch die gabs bei Conrad (2,98 €) – dran glauben.

Eine RGB-LED hat drei LED-Kristalle, Rot, Grün und Blau. Die Anschlüsse habe ich dieser recht undeutlichen Zeichnung entnommen, die ich irgendwo gefunden habe:

Nun bauen wir die Schaltung und schreiben einen kleinen Sketch:

Da ich nur ein Potentiometer zur Hand habe, entscheide ich mich, Grün auf 127 und Blau auf 255 zu setzen und nur Rot mittels Potentiometer zu steuern.


int sensorPin = 0;
int ledPinRot = 4;
int ledPinBlau = 5;
int ledPinGruen = 6;
int sensorValue = 0;  

void setup() {
  Serial.begin(9600);
}

void loop() {
  sensorValue = analogRead(sensorPin);
  Serial.print(sensorValue);  // Debug

  analogWrite(ledPinRot, sensorValue/4);
  analogWrite(ledPinGruen, 127);
  analogWrite(ledPinBlau, 255);  

  delay(10);
}

Das Ergebnis ist eine nette Stimmungsleuchte, die blau/lila-rotes Licht erzeugt:

Arduino: Erste Versuche mit dem Servomotor

netzwelten — Sun, 08 Nov 2009 19:10:05 +0000

Homepage moved to: www.netzwelten.net

Arduino: Erste Versuche mit dem Servomotor

Buch-Rezension zu "The Art of Unit Testing"

Johnny Graber — Sun, 08 Nov 2009 12:45:32 +0000

“The Art of Unit Testing” von Roy Osherove ist im Mai 2009 bei Manning erschienen. Das Buch behandelt Unit Testing in C#.

Zum Inhalt
Kapitel 1 zeigt die Basis von Unit Tests. Diese umfasst eine Definition der Begriffe, eine kurze Einführung zu Test-Driven Development (TDD) und eine Abgrenzung gegen Integrationstests. Den nicht alles, was sicht Unit Test nennt, ist auch wirklich einer.

Kapitel 2 hilft einem durch den ersten Unit Test. Nach der Auflistung der Vorteile die ein entsprechendes Test-Framework bringen folgt ein Rundgang durch NUnit. Dieser reicht von der Installation über die Einrichtung eines Test-Projekts zu Namenskonventionen bis hin zur Ausführung der Tests.

Wie man mit Stubs die Abhängigkeiten aufbrechen kann wird in Kapitel 3 gezeigt. Das Beispielprojekt hat zu beginn eine direkte Abhängigkeit zum Dateisystem. In 2 Schritten wird der Code so umgebaut, dass die Abhängigkeit aufgelöst werden kann. Mit einer kleinen Hilfsklasse, dem Stub, kann man dann genau die Antwort zurück liefern, die man für den Test der Übergeordneten Klasse benötigt. Dies kann in dem Beispiel sowohl ein Boolean sein wie auch eine Exception des Dateisystems.
Es folgt ein Abstecher ins Thema Dependency Injection. Denn der Stub, aber auch die konkrete Klasse mit der Logik, muss ja mit der aufrufenden Klasse verbunden werden. Es werden die Vor- und Nachteile der jeweiligen Ansätze dargelegt, damit man selber das zu seinem Problem passende auswählen kann.

Kapitel 4 zeigt wie man mit Mock Objekten die Interaktion mit der zu testenden Klasse prüfen kann. Mit einem selbst geschriebenen Mock wird das Prinzip erklärt, bevor in Kapitel 5 das Mock-Framework Rhino Mocks erklärt wird. Eine Übersicht der anderen verbreiteten Frameworks (wie TypeMock, NMock und NUnit.Mocks) rundet das Kapitel ab.

Die Organisation von Tests, Test Patterns und Continuous Integration bilden das Kapitel 6, während Kapitel 7 die Qualität der Tests behandelt. Lesbarkeit und Verständlichkeit sind Dinge, die auch bei Tests bedacht werden müssen.

Kapitel 8 hilft bei der Integration von Unit Tests in die Firma. Hierbei geht es nicht um die technische, sondern um die organisatorische Ebene. Osherove berichtet über seine Erfahrungen und liefert Antworten zu häufig aufkommenden Fragen und Problemen.

Wie man mit Legacy Code arbeiten kann zeigt Kapitel 9. Grosse Projekte ohne wirkliche Unit Tests benötigen spezifische Vorgehensweise. Auch hier werden Vor- und Nachteile der Ansätze aufgezeigt. Der Einsatz von Tools kann einem auch hier das Leben erleichtern. Depender oder NDepend können Abhängigkeiten anzuzeigen, was als Ausgangslage für Unit Tests dienen kann. Für Java Entwickler werden die Tools JMockit (vergleichbar mit TypeMock) und Vise erwähnt.

Design und Testbarkeit werden noch einmal ausführlich im Anhang A behandelt. Anhang B bietet eine kompakte Auflistung von Tools und Frameworks aus allen Bereichen von Tests.

Fazit
Ein sehr gutes Buch zur Kunst des Unit Testings. Auf rund 300 Seiten erfährt man unzählige Möglichkeiten zum sauberen testen. Das Buch richtet sich eher an Leser mit Erfahrungen im Bereich Unit Testing. Für Anfänger mag sich nicht immer erschliessen, worin die Vorteile der jeweiligen Ansätze liegen. Hat man sich aber mit den Problemen selber herumgeschlagen, braucht es nicht mehr viele Worte. Ich fand das Buch eine ideale Ergänzung zu Test Driven.
Der Anhang A hätte ein eigenes, „richtiges“ Kapitel verdient und einige Grafiken hätte man nochmals überarbeiten können. Davon abgesehen ist das Buch sehr gut.

Zum Buch
The Art of Unit Testing with Examples in .NET von Roy Osherove, 2009 Manning, ISBN 978-1-933988-27-6, 320 Seiten

Übersicht über Java Collections

dedeibel — Fri, 06 Nov 2009 11:27:43 +0000

Ein Kollege hat heute einen Link zu einer schönen Übersicht über die Standard Java Collections herumgeschickt.

http://www.torsten-horn.de/techdocs/java-collections.htm

Unreal Engine 3 - Kostenlos

Allan — Thu, 05 Nov 2009 18:44:27 +0000

Einfach nur toll. Unreal Engine 3 kostenlos. Das muss man sich mal auf der Zunge zergehen lassen. In

Java arrived!

r0m — Wed, 04 Nov 2009 13:42:07 +0000

Hallo zusammen, es ist eine Zeit her, dass das letzte Mal hier im Blog von mir was veröffentlicht wu

Macheist 4 - Countdown Widget

Allan — Sat, 31 Oct 2009 09:49:02 +0000

Dann will ich mal mein Countdown Widget vorstellen. Nichts besonderes nur damit man nichts ve

Kurze Einführung in die die Programmiersprache Processing

netzwelten — Fri, 30 Oct 2009 19:41:03 +0000

Neue Adresse: http://www.netzwelten.net

Kurze Einführung in die die Programmiersprache Processing

Unity 2.6 - Kostenlos

Allan — Fri, 30 Oct 2009 14:21:57 +0000

Unity 2.6 – True cross-platform game development, optimized. SAN FRANCISCO, CA – October

Endlich mal wieder was tippseln!

wint0r — Mon, 26 Oct 2009 19:48:45 +0000

Für die Leute die meinen Blog verfolgt haben tut es mir wirklich leid,dass so lange nichts kam – jede Menge Stress in der Schule,dann privat einiges was sich verändert hat,und wenn ich dann Zeit hatte war ich einfach zu müde,euch was schönes zu tippen.Das vor einiger Zeit versprochene Bashskript reiche ich hiermit nach,und danach werde ich mich der neuen Version von Ubuntu,9.10 oder auch “Karmic Koala”,zuwenden.(Dessen Release ich als religiösen Feiertag zelebrieren werde!)
Wie in meinem letzten Kurzartikel erwähnt gibt euch dieses Script genaue Informationen über Prozesse,deren Speicherbelastung und über angeschlossene USB Geräte.

#!/bin/bash chmod 755 echo "Na dann sehen wir uns mal an,was wir an Speicherplatz haben:" df -m -T echo "So,und nun noch einige kleine Infos,was alles an Arbeitsspeicher belegt wird:" ps -a -m echo "Angeschlossene USB-Geräte:" lsusb echo "Verbaute PCI - Slots:" lspci

Einfach per Konsole ausführen;wer möchte kann sich das ganze auch als Cronjob umschreiben – Hilfestellung hierzu kann ich leider keine bieten,da ich mich nur spielerisch mit der Programmierung in Bash beschäftigt habe und selbst nur mit Mühe einen selbigen hinbekommen konnte.Nun widme ich mich allerdings einem Blick auf Ubuntu 9.10 dass am 29.10 erscheinen wird.Ich kann es jetzt kaum noch erwarten (und lade mir deshalb gerade das Daily Release herunter,aber gehen wir einfach davon aus,dass ich es noch nicht teste!) und drum schaue ich mal,was sich seit 9.04 so getan hat.Ganz sicher ist schon einmal,dass Ubuntu in der neuen Version Änderungen aller Größenordnungen mit sich bringt.Die drei wichtigsten Ziele wurden stellvertretend von der Ubuntu Foundation zusammengefasst.(Bezieht sich auf die Desktopedition!):

Verbesserte Nutzerfreundlichkeit
Mehr Informationen für den Benutzer
Geschwindigkeitsverbesserungen bei alltäglichen Arbeiten

Diese Nutzerfreundlichkeit soll vor allem durch die erweiterte Dokumentation der Programme sowie einer intuitiveren Menüführung erreicht werden – doch einen wirklich großen Fehler begingen die Entwickler,in dem sie alle Icons aus dem Menü entfernten,”to increase the overview for normal users”.Das ganze sorgte für einen ziemlichen Aufschrei in der deutschssprachigen – und sicherlich auch über dem Ärmelkanal und dem Atlantik – Gemeinde,da niemand die Logik hinter dem ganzen Verstand.Es ist zwar möglich die Icons nachträglich zu aktivieren,aber mal ehrlich – wer ausser Textfetischisten die die Konsole trotzdem nicht mögen würde soetwas wollen … ?!

Folgendes Zitat von hier finde ich sehr interessant:

“Ubuntu 9.10 gives users more reasons than ever to seriously consider Linux at a time when many are thinking again about their operating system options. We are delivering a platform for users interested in an easy-to-use, great-looking, web-friendly operating system,” says Jane Silber, COO at Canonical. “A faster, more beautiful boot and login sequence, file and contact synchronisation through online services and great experiences on the most popular notebook, desktop and netbook models continue to drive Ubuntu into the mainstream of computing choices.”

Ich finde es einerseits toll dass sich Entwickler die Mühe machen,ihr Betriebssystem so Benutzerfreundlich wie nur möglich zu gestalten,aber andererseits … hatte Linux immer diesen Touch etwas “besonderes” zu sein.Bitte missversteht mich nicht,ich war immer ein absoluter Gegner dieser,”Wir sind 3l1t3″ – Mentalita,doch die meisten Linuxuser die ich kennenlernen durfte waren in der Lage und auch willig,logisch zu denken und nicht gleich Gott und die Welt zu verfluchen,falls etwas nicht nach dem ersten Anlauf klappte.Ich mache mir irgendwie ernsthafte Sorgen darüber,dass die Linxuwelt von DAUs überrannt wird … aber das sind nur meine Gedanken! Wünsche einen schönen Restabend und viel Spaß beim warten auf den 29.10!

LINQ to SQL vs ADO.NET Entity Framework

depaule — Mon, 26 Oct 2009 14:45:22 +0000

So habe jetzt mal LINQ to SQL ausprobiert. Ist auch soetwas wie ein OR-MAPPER. Hat auf jedenfall einen besseren Wizzard als ADO.NET EF und ist bei der Laufzeituntersuchung von über 100.000 Datensätzen (mit über 100 Spalten) mit 20 sec 5 sec schneller als das EF

ADO.NET Entity Framework mit Oracle

depaule — Mon, 26 Oct 2009 10:34:05 +0000

Habe heute mal das ADO.NET Entity Framework (ein OR-Mapper) von Microsoft ausprobiert. Für den Zugriff auf die Objekte habe ich LINQ verwendet. IMHO hat es eine sehr schöne Syntax.
Leider bietet Microsoft keinen Treiber für Oracle also habe ich diesen von http://www.devart.com/ verwendet.
Schein ziemlich schnell zu sein…
Werde noch weitere Testes machen. Praktisch finde ich auch die Graphische Darstellung des Datenmodells