Wenn ich die Morgentoilette wie Softwareprojekte schätzen würde …

Das Schätzen der Dauer von bestimmten Aufgaben ringt mir entweder enorme Disziplin oder falsche Ergebnisse ab. Zu aller erst wollte ich an dieser Stelle kurz beschreiben wie ich die tatsächliche Programmierarbeit im Alltag anpacke. Aber nach kurzer Reflexion wurde mir klar, dass das nicht von Nöten ist. Die Frage wie man Software-Entwicklungspakete schätzt hängt nur zu einem kleinen Teil davon ab wie man sie in Angriff nimmt.

Ich bin jetzt bald 5 Jahre in der Privatwirtschaft als professioneller Entwickler tätig. Da schnappt man zwangsläufig auf wie das eine oder andere Projekt geplant wurde, wie es ablief und wie die einzelnen Kollege schätzten und wie genau sie damit waren. Gute Voraussetzungen um auch selbst das Schätzen von Programmieraufgaben gut hinzubekommen. Und doch, wenn ich gefragt werde wie viel Zeit eine bestimmte Aufgabe wohl in Anspruch nehmen wird stocke ich kurz. In meinem Hirn beginnt es zu rattern. Ich stelle mir dann immer folgende Fragen:

  • Geht das?
  • Wie geht das?
  • Was muss ich machen?
  • Welche Schritte werde ich durchführen um den SOLL-Zustand zu erreichen?
  • Wie lang werden die einzelnen Schritte es zu bauen dauern?

Und wenn ich mich nicht sehr zusammen reiße, mir sprichwörtlich auf die Lippe beiße, haue ich gleich eine Schätzung raus. Als Basis verwende ich in diesen Momenten 30 Sekunden Überlegungen. 30 Sekunden! Was ist das schon wenn man ein Problem analysieren muss?

Heute, während ich mir die Zähne putzte und schon wieder um 10 Minuten zu spät dran war, kam ich auf die Frage wie ich wohl die Zeit im Band jeden Morgen schätzen würde. Gehen wir es einfach nach dem oben gefundenen Fragenkatalog an:

Frage Antwort
Geht das? Die Konkurrenz tut es. Die Kunden tun es. Wir können es auch. Ja.
Wie geht das? Hygieneartikel vorausgesetzt, werden eben diese großflächig oder punktuell – wiederum abhängig vom Hygieneartikel – aufgetragen und angewendet.
Was muss ich machen? Ich muss mich waschen und kämmen.
Welche Schritte werde ich durchführen um den SOLL-ZUSTAND zu erreichen? Zu aller erst muss ich mir die Zähne putzen. Die Nötigen Tools habe ich, auch Zahnpasta, die zwingend vorhanden sein muss, ist im Kästchen. Duschgel sowie Dusche mit frei hängendem Brausekopf sind bereits im Haus. Eben diese wird in Betrieb genommen, der Körper nass gemacht um anschließend eingeschäumt zu werden.

Wenn eine optimale Schaumabdeckung erreicht ist, wird eben der Schaum mit Wasser – Temperatur ca. 5° über der eigenen Körpertemperatur – abgespült bis alle Reste des Duschgels abgewaschen sind. Danach muss der Körper mit einem Handtuch trocken gerieben werden. Wenn eine optimale Trocknung erreicht ist, kann mit dem Kämmen begonnen werden. Wenn der Kamm das Haar ohne hängen zu bleiben durchfahren kann, ist der Zielzustand erreicht.

Wie lange werden die einzelnen Schritte es zu bauen dauern? Zähneputzen 3 Minuten. Duschen 10 Minuten. Kämmen 2 Minuten. Projektlaufzeit: 15 Minuten.

Hört sich nach einer seriösen Schätzung an, oder? Dann sehen wir uns die Projektumsetzung aufgrund dieser Schätzung einmal in der Praxis an:

Projektstart: Ich habe verschlafen und bin schon einmal 10 Minuten zu spät dran. Doch das hält mich nicht auf. Schnell in’s Bad: Zahnbürste und Zahnpasta gepackt, Zähne putzen und tatsächlich 3 Minuten später blitzt das Kauwerkzeug. Ab in die Dusche. Herrje, die Haare sind schon ganz fettig und gehören auch gewaschen. Als werden diese mit einem Shampoo eingeschäumt bevor der restliche Körper mit Duschgel behandelt werden kann. Danach die Haare und den Rest abspülen. Herrje, ich bin schon 3 Minuten über der Zeit. Schnell in’s Handtuch um sich den Haaren widmen zu können.

Während ich mir die nassen Haare kämme, bemerke ich, dass der Bart schon wieder zu lang ist. Nachdem die Haare glatt nach hinten anliegen schäume ich mein Gesicht ein und kratze mit dem alten Rasierer gegen den Strich die schwarzen Stoppel aus selbigen. Gesicht abspülen. Nun bemerke ich, dass Blut aus den neu geschnittenen Mikro-Löcher im Gesicht quillt. Ärgerlich tupfe ich es ab doch es stehen gleich wieder die kleinen Blutperlen auf der Haut. Ich entscheide mich die Löcher  mit Creme zu stopfen und schmiere das Gesicht ein. Nun bin ich insgesamt schon 8 Minuten drüber.

Nachdem mir kein Blut mehr über die Lippe tropft, lege ich den Rasierer zurück in’s Kästchen. Dabei bleibt mein Blick auf den Wattestäbchen hängen. Ich schnappe mir welche und sorge dafür, dass ich den restlichen Tag ein Stechen in den Ohren habe. Somit bin ich 10 Minuten drüber.

Nachdem ich dann auch noch Deo aufgetragen habe wird es Zeit für das Fönen. Die Haare sind wieder trocken worauf ich sie erneut kämme. Ich bin 15 Minuten drüber, schlüpfe in Hose und T-Shirt und bin fertig. Ich habe die doppelte Zeit von der geschätzten Zeit gebraucht. Warum?

Zum einen weil ich furchtbar langsam im Bad bin und zum anderen weil ich hauptsächlich die Frage nach der Möglichkeit beim Schätzen im Kopf hatte. Ich bin kaum darauf eingegangen was schief gehen kann, habe mir nicht die Zeit genommen noch einmal zu überlegen welche Möglichkeiten ich vergessen (Haare waschen, Fönen) könnte oder was Situationsabhängig (Rasieren) ist. Das hat sich alles gerächt.

Deshalb beiße ich mir häufig auf die Lippe und überlege noch einmal bevor ich eine Zeit nenne.

Posted in Software Development, webdeveloping | Tagged , | Leave a comment

No na ned – Bug oder Feature in Eclipse?

Heute hatte ich ein seltsames Problem: Ich hab mir mit Antlr Java-Files aus meiner Grammatik generieren lassen. Durch die Art wie die Elemente und Labels hießen, kam es zustande, dass im erzeugten Code Klassennamen vorkamen die sich nur durch Großkleinschreibungen unterschieden.

Prinzipiell ist daran ja nichts verkehrt, da der Java-Compiler das problemlos frisst und funktionierenden Byte-Code ausspuckt. Allerdings hat das Eclipse in Verbindung mit einem Windows-System Probleme.

Folgender Code wird also scheitern:

public class TestibertBase {
}

class TestibertDefOne extends TestibertBase {
}

class TestibertdefOne extends TestibertBase {
}

Ich kann es natürlich nicht beweisen, allerdings traue ich mich wetten, dass es damit zu tun hat, dass Windows bei File-Namen nicht zwischen Groß- und Kleinschreibung unterscheidet und deswegen zwei Class-Files nach dem Compile-Vorgang findet die vermeintlich gleich sind. Das darf natürlich nicht sein und deswegen gibt es dann diese Fehlermeldung:

class file collision a resource exists with a different case

Im Eclipse selbst kann man dieses Problem nur innerhalb eines Files nachstellen. Möchte man 2 Java-Files anlegen, beschwert sich das Eclipse bereits, dass man nicht Files mit dem selben Namen anlegen darf.

Posted in Tech | Tagged , | Leave a comment

Sprachdesign und Toolchains – Ein erster Einblick

Im Moment bin ich wieder verstärkt – jedenfalls was meine Arbeit für Lehrveranstaltungen auf der Uni angeht – mit einem Thema beschäftigt, dass mich gleichzeitig abschreckt und begeistert: Dem Design von Computersprachen. Da ich für meine Bac.-Arbeit, die seit gefühlten 100 Jahren überfällig ist, eine DSL samt IDE für ein Java getriebenes Programm entwickle, halte ich hier kurz fest, was ich bei meiner Recherche heraus gefunden habe und wie mein Entscheidungsprozess ablief.

Zu aller erst, mehr Not denn Tugend, habe ich mit dem Backend der Sprache begonnen um mit Java-Code das zu erreichen was ich möchte. Dann habe ich mit ein paar Builder-Klassen ein Fluent Interface drauf geklatscht und damit mal meine ersten Programme geschrieben. Nachdem das funktioniert hat, habe ich mit dem in Java eingebauten Compiler Toolkit, einer kleinen Lib (Compilation Toolbox) die das ganze einfacher handlebar macht, ein paar Zusatzlibs von Fifesoft für Swing um den Editor (Syntax-Highlighting, Auto Complete, etc.) eine Minimal-IDE zusammen gestöpselt mit der man ausprobieren kann wie das ganze funktioniert.

Als das mal lief, hielt ich Rückfrage bei meinem Betreuer ob das soweit schon mal gut aussah. Als hier das OK kam, ist die Stoßrichtung klar: Es muss eine echte DSL her und eine IDE die den Ansprüchen einer EUP-Anwendung gerecht wird. Ohne viel über die Sprache oder die IDE verraten zu wollen, kann ich doch sagen, dass ich einen Editor wie den von Alice verwenden möchte:

Allerdings gibt’s gleich mehrere Probleme um hier mit möglichst wenig Aufwand an eine solche Komponente zu kommen:

  • Der Source-Code von Alice, jedenfalls einer alten Version, ist zwar öffentlich zugänglich und auch legal zu verwenden, allerdings ist der Code mörderisch komplex. Jedenfalls macht es den Eindruck als wäre es einfacher so eine Komponente selbst zu programmieren als sich durch die Definition in Alice durch zu wühlen.
  • Die Begrifflichkeit ist nicht greifbar. Aus dem Alice-Package-Namen ist heraus zu lesen, dass es ein Schabloneneditor bzw. Stencil Editor ist. Allerdings versteht die Fachliteratur etwas anderes darunter. (Auch wenn ich finde, dass der Name Stencil based Editor viel Sinn macht für diese Art Editor.)

Als diese Recherche anstand, habe ich es noch auf einem deutschen Java-Forum und Stackoverflow probiert. Doch dort kam auch nichts zurück, außer die Erkenntnis wohl selbst ran zu müssen. Zumindest bekam ich im Java-Forum interessanten Input was die Implementierung der DSL betraf.

Ich dachte von Haus aus nur an Antlr. Dort bekam ich allerdings noch die Tools xText und MPS empfohlen. Wo ist der Unterschied zwischen diesen Tools? Ich habe mir das etwas angeschaut – jeweils ca. 2h Arbeit rein gesteckt, Beispiele ausprobiert und Tutorials gelesen – um hier einen raschen Überblick zu bekommen. Das war mein Ergebnis:

Tool Zweck Stärken Schwächen
xText Sprach- und IDE-Entwicklung Es kann in Eclipse eine Sprache entworfen werden und gleichzeitig eine IDE die auf Eclipse aufbaut entwickelt werden. Das bedeutet, man hat das komplette Eclipse RCP zur Verfügung, bekommt einen Editor mit Auto Complete etc. geschenkt. Man bekommt Eclipse. Einen fetten Klotz der lange Ladezeiten hat. Zudem ist das Testen der generierten IDE mühsam, da dazu das Projekt exportiert werden muss. Und ich hab in 5min geschaft, das Tutorial-Projekt zu zerschießen, da die IDE generierten Code nicht selbst aufräumt beim erneuten Generieren. (Kein großes Drama, aber sehr nervig.) Die Syntax ist sehr gewöhnungsbedürftig.
MPS Sprach- und IDE-Entwicklung Es kann in einem IntelliJ-Editor die Sprache entworfen werden. Das Konzept ist anders als das von xText und dröselt die Sprache und den dazugehörigen Editor in ein paar Konzepte auf. Diese werden dann beschrieben. Die Syntax ist zwar gewöhnungsbedürftig aber wenn man sich etwas damit beschäftigt hat, ist die logische Struktur sehr eingängig. Es können – im Gegensatz zu xText! – keine eigenen Editoren geschrieben werden. Es wird immer der Standard-Text-Editor von IntelliJ verwendet. Natürlich mit allen Features von IntelliJ (und das sind eine Menge!), allerdings interessiert mich das im EUP-Kontext kein Stück.
Antlr Sprachentwurf (Compiler, Parser, Lexer, etc.) Ein kleines Java-Tool für das es leichtgewichtige IDEs gibt. Wer mit lex und Yacc schon gearbeitet hat, findet hier sehr schnell rein. IMHO ist es auch leichter zu bedienen. Es ist nur der Compiler-/Parser-Generator und kein umfassendes Tool zur IDE-Generierung. Es gibt weniger Tuts zu Antlr als zu MPS oder xText.

Ich habe mich dann für Antlr entschieden da mir:

  • SWT nicht sympathisch ist.
  • xText nicht sympathisch ist.
  • MPS leider keine anderen Editoren zulässt. Auch wenn man die händisch programmiert.

Nachdem geklärt war, welches Tool ich verwende, juckte es mich sofort in den Fingern die IDE und diesen Schabloneneditor zu entwickeln. Allerdings brauche ich als erstes eine Sprache für die ich diese Komponente schreiben kann. Also ab an’s Sprach-Design. Nun wird es interessant, welche Komponenten hat den eine Sprache überhaupt? Wie setzte ich das um?

Zu dem Thema wird’s dann wieder einen kleinen Artikel geben. Im Moment kann ich dazu noch nichts fundiertes schreiben.

Posted in Java, Software Development | Tagged , , , | Leave a comment

Angular JS – Kleine Tools ganz schnell

Ich weiß, eigentlich bin ich noch mindestens einen Post zum Thema Selenium schuldig. Allerdings ist das ein sehr leidiges Thema. Ich werde meine Erfahrung noch nachliefern. (Durch die ganzen Probleme die ich während des Betriebs hatte, werden es vielleicht sogar 3 Posts insgesamt.) Allerdings interessiert mich im Moment das Coden mehr als das Testen.

Im Zuge eines aktuellen Projekts in der Arbeit bin ich mit Angular in Berührung gekommen. Angular macht vieles richtig und vieles leichter. Natürlich nicht alles und so einiges wird auch zu einer riesen großen Verrenkung. Wen es interessiert, kann sich ja einmal durch die Newsgroups zum Thema for-Schleifen als Knoten-Element graben.

Mein Thema heute soll allerdings sein, wie schnell man sich mit Angular nette Tools zusammen basteln kann. Ich für meinen Teil zB. war heute auf der Suche nach neuer Musik. Ein ganz vernünftiger Service ist dabei echonest. Ich hatte mir sogar schon einmal einen halbwegs funktionierenden Java-Client gebaut, der durch meine MP3-Sammlung gelaufen ist um per Echonest dazu passende Künstler zu finden.

Das war ein nettes Projekt, dass allerdings gleich an drei Punkten gekrankt hat:

  1. Man muss seinen Echonest-Developer-Key weiter geben, wenn man möchte, dass das Programm auch anderen zu Gute kommt.
  2. Man kann höchstens Hausnummer 60 (ich weiß es nicht mehr wie viele es wirklich sind) Requests in der Minute absetzen. Da ich zu Faul war eine Sync-Queue zu bauen, die darauf aufpasst, dass tatsächlich nur 60 Requests in der Minute ausgeführt werden, habe ich das Projekt einschlafen lassen.
  3. Ich war zu faul eine brauchbare UI dafür zu bauen. Dafür war es mir wieder nicht wichtig genug.

Hier kommt Javascript bzw. Angular in’s Spiel. Es liegt in der Natur der Webanwendung, die UI mit HTML gestalten lassen zu können. Da mit jQuery eine sehr einfache Ajax-Lib zur Verfügung steht und JSON in JS eingebacken ist, habe ich mir mit Angular einen abgespeckten Client in 10 Minuten schnell selbst gebaut.

Wie man sieht, kann man den Client so gestalten, dass er gleich auch zu Suchanfragen auf Youtube und Google führt. (Natürlich nur um sich die Band-Geschichte auf Wikipedia durch zu lesen. *hüstel*)

Aber genug der Worte, wie sieht denn der Code nun aus?

<!DOCTYPE html>
<html ng-app>
	<head>
		<title>Dirty little searcher</title>
		<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.5/angular.min.js" type="text/javascript"></script>
		<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js" type="text/javascript"></script>
	</head>
	<body ng-controller="SearchController">
		<div>
			<input type="text" ng-model="searchInput">
			<button ng-click="search()">Search!</button>
		</div>
		<div>
			<div>These {{items.length}} bands sound like "{{searchInput}}": </div>
			<div ng-repeat="item in items">
				<b>{{item.name}}</b>
				<a href="http://www.youtube.com/results?search_query={{item.name}}">On youtube</a> | <a href="http://www.google.at/search?q={{item.name}} ">Links on google</a>
			</div>
		</div>

		<script>
			function SearchController($scope) {
				$scope.items = [];
				$scope.searchInput = '';
				$scope.search = function() {
					var url = 'http://developer.echonest.com/api/v4/artist/similar?api_key=FILDTEOIK2HBORODV&name=' + $scope.searchInput;
					$.ajax({
						url: url
					}).done(function(data) {
						$scope.items = data.response.artists;
						$scope.$apply();
					});;
				}
			}
		</script>
	</body>
</html>

Das war es auch schon. 37 Zeilen im ganzen. Das kleine Tool funktioniert – glaube ich, ausprobiert habe ich es nicht – nur lokal, da ich auf einen REST-Service zugreife. Wird die Seite gehostet, dürfte dass gegen das SOP verstoßen. Wer möchte kann es natürlich auf JSONP umbauen und hosten.

Es war mir zu klein um es auf Github zu stellen, also hänge ich es hier nur als File an.

Posted in javascript, webdeveloping | Tagged , , , , | Leave a comment

Komplexes JS und Testen – Teil 1

Wenn man seine Lieblingssuchmaschine bemüht und nach bereits gegangenen Pfaden fürs Testen von Webseiten und Javascript sucht, wird man sehr schnell auf eine Fülle von Javascript-Unit-Test-Frameworks stoßen. Mit diesen Frameworks ist auch nichts verkehrt, allerdings gehen diese selten auf die UI (also das vom JS manipulierte DOM) sondern auf die Javascript-Controller los.

Die ganze Anwendung testen

Das mag alles sehr nett sein um seine Logik auf eine gewisse Fehlerquote zu senken, es hilft einem allerdings nicht dabei sicher zu stellen dass in dem Javascript das auf dem DOM-Baum operiert auch alles stimmt.

Wo braucht man das denn überhaupt? Da gibt’s Anwendungsfälle wie z.B.:

  • Man verwendet eine Templating-Sprache (Angular, JQuery Templates, etc.) und operiert auf den erzeugten DOM-Objekten und möchte sicherstellen, dass der erzeugte DOM-Baum den Anforderungen entspricht.
  • Man möchte sicher stellen, das deployter Code auch so läuft wie man das möchte. Also zB. automatisch sicherstellen, dass man sich in einer Webanwendung anmelden kann und die verschiedenen Services aufrufen kann.
  • etc.

Vor allem die Verfügbarkeit per Website, also nicht nur den dahinter sitzenden REST-Services, zu testen, setzt folgende Anforderungen voraus:

  1. Es muss in einem Browser laufen der auch Javascript unterstützt.
  2. Es muss vom CI-Server angestoßen werden können.
  3. Die Tests müssen leicht gewartet werden.

Ein Bonus ist natürlich, wenn die Tests schnell erstellt sind. Mir persönlich hat vor allem Punkt 3 Kopfzerbrechen bereitet. Ich ging dann auf die Suche was es da alles gab. Neben den oben erwähnten JS-Testframeworks die Controller testen sollen, fand ich auch Jasmine. Mit Jasmine wäre es auch möglich, mittels Plugins wie zB. das Jamine-JQuery-Plugin, allerdings hätte man hier noch nichts gewonnen. Man müsste sich seine Test-Suite weiterhin aufbauen die dann von einem Server ohne X-Server gestartet werden könnte.

Mit Selenium Grid fand ich genau so etwas. Die Architektur teilt sich dann in drei Teile auf:

  1. Selenium-Tests. Die Tests sind vollkommen unabhängig von der Infrastruktur die dann tatsächlich testet. Die Tests werden wie normale Selenium-Tests geschrieben und steuern dann per RemoteWebDriver den Grid Hub an.
  2. Grid Hub Der Hub ist die zentrale Anlaufstelle für alle Tests. Dort registrieren sich die einzelnen Grid Nodes die dann die tatsächliche Arbeit, also das Fernsteuern der Browser um die Tests auszuführen, übernehmen. Der Hub weiß genau, welche Node welchen Browser unterstützt und kann dementsprechend die Arbeit verteilen. Vorteil: Auch paralleles Testen ist möglich.
  3. Grid Node(s) Die Nodes sind Systeme auf denen die Browser laufen und das Node Program. Nodes registrieren sich beim Start beim Hub und geben bei der Anmeldung ihre Eigenschaften mit. Eine Node könnte zB. dafür da sein die Windows/IE7-Tests auszuführen, eine andere Node die IE8-Tests und die dritte die Chrome- und Firefox-Tests auf einer Linux-Maschine. (Verfügbar ist Selenium Grid für Mac OS, Linux Distros und Windows.)

Selenium Grid – All in one für verteiltes Testen

Um Selenium Grid aufzusetzen benötigt man nur etwas Geduld beim Konfigurieren, das JDK ab Version 5 und Rechner auf denen man das testweise aufsetzt. Natürlich genügt auch ein Computer um damit warm zu werden.

Im nächsten Teil werde ich zwei kleine Testprojekte vorstellen, die eine Website auf verschiedenen Browsern über Selenium Grid testen. Dabei zeige ich, wie man eine nette kleine Test-Suite mit Java-Unit-Tests, der Selenium IDE, den Browsern Chrome und Phantomjs sowie ant erstellt.

Die Integration in ein CI-System der Wahl sollte dann nicht mehr schwer fallen.

Posted in Software Development, javascript, webdeveloping | Tagged , , , , , , | Leave a comment

Kleines Style-Up

Ich bin jetzt schon länger nicht dazu gekommen mal wieder etwas zu schreiben, auch wenn ich mehr als genug Ideen für Artikel hätte, aber heute habe ich mir mal zwei stunden Zeit genommen, das Internet nach brauchbaren Texturen durchforstet und das CSS ein wenig angepasst.

Der Blog läuft mit dem zbench-Theme und lief bis heute auch gut so schmucklos er auch war. Allerdings stören mich zwei Dinge:

  1. Auf meinem Galaxy Nexus (1280×720 Auflösung) sieht die Seite unpraktisch aus. Ich muss rein zoomen und habe dann die Side-Bar immer außerhalb des Bildes -> horizontale Scoll-Balken. (Man fragt sich vielleicht wer so eitel ist und seinen eigenen Blog liest, aber ich bin eher picken geblieben nach dem ich meine Media-Queries ausprobiert habe und die nicht so funktionierten wie ich das wollte …)
  2. Die alte Seite sah echt bescheiden aus. Es war wortwörtlich grau in grau. Ich mag es zwar schlicht, aber das war etwas zu schlicht …

Im ersten Schritt habe ich ein Media-Query eingebaut, dass die Sidebar bei einer max. Breite von 1000px als normales DIV unter die Posts legt. Ich hab dann noch recherchiert ob sich das etwas schöner mit CSS lösen lässt, doch es half alles nichts weswegen ich auf Stackoverflow nach einer Lösungen gesucht habe.

Ich glaube ich werde beim PHP-Hack bleiben. Ist auf jeden Fall die einfachere Lösung im Vergleich zu diesem Herumgepfrumpftel mit JS und den DIPs.

Für das Style-Up hab ich einen Hammer aus meiner Werkstatt auf einem Blatt Papier fotografiert, und von einem Deviant-Art-Künstler namens ftourini das tolle Hintergrundbild gefunden. Das beste an der Sache: Es ist gratis :-)

Dann noch ein wenig mit den Farben und Schatten herum gespielt und dann sah die Seite schon so aus wie sie es jetzt tut.

Jetzt fehlen noch 3 Sachen:

  1. Mobile Browser erkennen und zusätzliches CSS-File einbinden. (Oder das ganze per Media-Queries machen wenn’s da eine Lösung ohne JS gibt.)
  2. Den Header stylen. Ich hab die NAV-Bar oben zur Zeit raus geschmissen weil mir noch nichts eingefallen ist, wenn ich sie passend zur restlichen Seite style.
  3. Einzelansicht von Posts fixen: Da happerts mit der Sidebar.
Posted in Uncategorized | Tagged , , | Leave a comment

Taktik in Rollenspielen

Wie macht man ein Taktikrollenspiel? Die Frage ist gar nicht leicht zu beantworten ohne die Komplexität des Spiels sehr in die Höhe zu treiben. Wenn man sich z.B. Warhammer, Warhammer 40K oder ein anderes Rollenspiel anschaut, wird offensichtlich, dass hier viel Komplexität darauf verwendet wird dem Spieler zu erlauben taktisch zu spielen.

Komplexität anhand eines Beispiels

Sieht man sich z.B. eine Warhammer Fantasy Runde Edition an: Es stehen sich Dunkelelfen und Zwerge gegenüber. Die Zwerge verfügen über keine Magie und keine Kavalerie. Dafür haben sie Runen um sich gegen Magie zu wehren und schwere Infanterie. Gut gepanzert, harte Attacken sowie robuste Konstitution. Die Elfen sind das genaue Gegenteil: Schnell, agil, kaum bedrohlich in ihren Attacken und gedeckt durch starke Kampfmagie.

Jetzt beginnt die Runde. Die Zwerge sind zuerst am Zug. Bewegungsphase. Die Zwerge mauern sich ein. Magiephase. Ein Zwerg zaubert nicht. Schussphase. Die feindlichen Einheiten sind außerhalb der Reichweite der Musketen- sowie der Bogenschützen. Die Kanonen erreichen die feindlichen Armbrustschützen. Man schätzt die Distanz. Sagt an, würfelt die Abweichung, erhält eine Fehlfunktion worauf man noch einmal wegen der Fehlfunktion würfelt. Die Kanone hat eine Ladehemmung. Nichts passiert. Nahkampfphase. Es gibt noch nichts zu kämpfen.

Die Dunkelelfen sind am Zug. Bewegungsphase. Ein Angriff wird angesagt. Die leichte Kavallerie bricht aus und positioniert sich in der Flanke eines schweren Infantrieregiments. Der Rest der Armee bleibt stehen. Magiephase Der Zauberer versucht zu zaubern. Würfelt einen Pasch. Nun muss noch einmal gewürfelt werden um herauszufinden was bei einem Zauberpatzer passiert. Der Zauberer explodiert. Schussphase Die Zwerge erreichen niemanden. Nahkampfphase. Die Zwerge verlieren drei Mann, würfeln Mist beim Moraltest und fliehen. Die Kavallerie verfolgt die lahmen Zwerge und reibt das komplette Regiment auf.

Jetzt habe ich sehr oberflächlich eine einzige Runde in einem Warhammer Fantasy Spiel skizziert. Das interessante dabei: Es hat sich eine Einheit bewegt und es fand ein Nahkampf statt. Die Spieler waren aber geschätzte 10 Minuten beschäftigt. (Lassen wir den Aufwand die Figuren zu sammeln, zusammen zu kleben und zu bemalen mal als Voraufwand komplett aus.) Das ist sehr viel Aufwand nur um eine Runde taktisch spielen zu können. Das muss auch einfacher gehen!

Ein paar Ideen aus der KI

Wenn man in der künstlichen Intelligenz über Agenten in Spielen reden, muss man normalerweise auch die Art Spiel definieren in dem wir uns bewegen. Vereinfacht gesagt gibt es vier Arten von Spielen. In der folgenden Tabelle stelle ich die Kategorien und ein paar Vertreter daraus dar:

Deterministisch Zufallbehaftet
Komplette Information Schach, Go, Dame, etc. Backgammon, DKT, Monopolie, etc.
Nicht komplette Information Schiffe versenken, Blindes Tic Tac Toe, etc. Poker, UNO, Scrabble, etc.

Wie hilft mir das jetzt bei der Gestaltung eines Spiels das relativ einfach sein soll und dennoch möglichst taktisch spielbar sein soll? Zum einen zeigt es auf, dass Informationen zu verstecken nicht umbedingt Taktik aus dem Spiel nimmt. Sieht man sich Schach oder Go an, ist klar, dass hier unendlich viele Variationen von Spielen (in der Annahme, dass es im Spielgraph Zyklen geben darf, Spieler Spiele herauszögern, etc.) gibt. Also nicht weniger als es z.B. in einem Warhammer-Spiel möglich ist.

Zum anderen ergibt sich alleine durch die Darstellung eine interessante Analyse puncto Schach:

  • Es gibt eine sehr überschaubare Anzahl an Figuren.
  • Die Figuren arbeiten im selben Spielfeld auf die selbe Art. Sie kann auf kein Feld fahren auf dem bereits eine Figur der eigenen Farbe steht, fährt sie auf ein Feld das von einer Figur der anderen Farbe belegt ist, so wird diese feindliche Figur geschlagen.
  • Eine jede der Figuren unterscheidet sich nur durch die Art wie sie sich bewegt.
  • Wird der König geschlagen verliert der dazugehörige Spieler die Partie.

Diese sehr einfachen Sätze bieten bereits ein derart komplexes Spiel, dass ganze international agierende Konzerne damit beschäftigt waren nicht nur die nötige Hardware sondern auch das nötige theoretische Fundament auszuarbeiten um endlich den besten menschlichen Spieler von einem Computer besiegen lassen zu können. Zudem ein Schachspiel in 3 Minuten aufgebaut ist und die Zuggeschwindigkeit nur durch die eigene Hirnkapazität bestimmt wird und nicht durch komplexes Regelwerk.

Einfachheit als Trumph

Wie bastelt man sich aus dieser Erkenntnis nun etwas interessantes zu spielen? Ich gehe so vor: Man sucht sich die Spielart aus. Also zum Beispiel ein Spiel mit Zufallselementen und kompletter bzw. perfekter Information. Dann definiert man sich die Eigenschaften die allen Figuren gemein sein sollen:

  • Figuren bewegen sich in einem Spielfeld ähnlich dem von Schach.
  • Es kann immer nur eine Figur pro Runde bewegt werden.
  • Figuren können sich in einem bestimmten Muster auf dem Feld bewegen. Ähnlich dem von Schachfiguren (nur diagonal, nur waag- oder senkrecht, etc.)
  • Figuren haben bestimmte Verteidigungs- und Angriffswerte. Treffen zwei Figuren aufeinander würfeln beide mit einem W6. Ist das Würfelergebnis des Angreifers plus seines Angriffwerts höher als as Wüfelergebnis des Verteidigers plus seines Verteidigungswurfs fällt der Verteidiger und wird von der anderen Figur ersetzt. Fällt er nicht führt er einen Gegenschlag aus der nach dem selben Muster mit vertauschten Rollen bestimmt wird. Bleiben beide am Leben, bleibt der Angreifer an einem angrenzenden Feld zum Verteidiger stehen.
  • Verfügt ein Spieler über keine Figuren mehr hat er verloren.
  • Eine jede Figur kostet Punkte. Ein Spieler kann sich nur um N Punkte für eine Partie Figuren aufstellen.

Mit diesen Regeln habe ich ein paar Elemente aus Schach genommen, ein paar Elementen aus Tabletopspielen und bereits ein kleines Spielsystem geschaffen. Nun gilt es noch die Protagonisten dieses Spiels zu definieren:

Name Bewegungsmuster Verteidigung Angriff Zusatzeigenschaften Punkte
Ritter Waag- oder senkrecht 2 2 - 3
Bauernmilizionär Waag- oder senkrecht, 1 Feld weit 1 0 Kann nur bewegt werden solange sich ein Ritter in der eigenen Armee befindet. 1
Bihandkämpfer Diagonal, max. 3 Felder weit 2 0 - 2
Phalanx-Kämpfer Waag- oder senkrecht, max. 3 Felder 1 1 Bekommt +1 zu seinem Verteidigungswert solange er an ein Feld angrenzt auf dem ein Phalanx-Kämpfer der eigenen Farbe steht. 2
Belagerungsturm Waag- oder senkrecht, max. 2 Felder weit 3 -3 - 2

Der Fantasie sind keine Grenzen gesetzt aber mit diesen einfachen Regeln und diesen wenigen Figuren bekommt man schon ein Spiel zusammen, dass vor allem davon lebt angriffslustig zu spielen. Verteidigen wird bestraft denn man muss zwei mal Würfeln gewinnen als Verteidiger aber nur einmal Würfeln als Angreifer um die andere Figur zu schlagen. Um das zu entschärfen, gibt es den Belagerungsturm als sehr schwache Offensiveinheit, die dafür schwer zu knacken ist.

Wozu das ganze? Mit diesem gedanklichen Rahmen kann man schnell Spiele erstellen. Ob sie Spaß machen muss man allerdings mit Freunden am Tisch selbst ausprobieren.

Doch was bringt mir ein so simples Spiel für die Idee ein Rollenspiel zu entwickeln? Dazu kommen ich im nächsten Artikel.

Posted in Random | Tagged , , , , | Leave a comment

JSON with Padding – Was ist JSONP?

Eigentlich muss man dazu nicht viel sagen, da es bereits auf Wikipedia einen ganz brauchbaren Artikel namens JSONP dazu gibt. Doch da ich gerade ein Framework darauf umbauen muss, dachte ich mir, ich halte einfach fest was mir beim implementieren so auffällt.

Prinzipiell ist JSONP schnell erklärt: Wenn man einen REST/JSON-Service auf einem anderen Server als dem auf dem die Website läuft aufrufen möchte, kann man das nicht mit den gängigen Ajax-Methoden machen, da man hier ja eine Domängrenze überschreitet. (Mehr Details gibt’s unter dem Stichwort Same Origin Policy)

Wie das so ist als Software-Entwickler kümmert man sich allerdings in erster Linie nicht um die Sicherheit sondern darum, das Werkel endlich zum Laufen zu bringen. Natürlich könnte man auch einen serverseitigen Service-Wrapper bauen, der als Proxy fungiert und die Requests auf den entfernten Server ausführt und die Resultate zurück gibt.

Das hätte zwar den Nachteil, dass extra Aufwand auf dem eigenen Server getrieben wird, hätte allerdings auch den Nachteil, dass Session relevanten Daten abgegriffen werden können, die Daten serverseitig überprüft werden können, etc.

Das ist nicht immer eine Option. Weder das Zeit/Geld-Budget stehen dafür zur Verfügung, noch die Performance-Resourcen. Also bleibt die Frage: Was ist JSONP jetzt genau?

Das Prinzip bricht die Sicherheitsmechanismen auf durch die Eigenheit, dass der Browser zwar keine Ajax-Calls auf andere Server machen möchte allerdings bereitwillig Script-Files von anderen Servern einbindet! Man kennt diese Script-Tags in HTML Files:

 <script type="text/javascript" src="http://extern.server.com/js/file1.js">
 </script>

Nehmen wir nun an, unter http://extern.server.com/Data/ ist ein Service erreichbar der JSON zurück gibt, wenn wir ihm Param übergeben. Das ganze könnte dann in’s HTML File so eingebunden werden:

Da gibt’s dann natürlich Brösel, da ein JSON-Objekt per se noch keinen gültigen Javascript-Code macht. (Dazu müsste es zumindest einer Variable zugewiesen werden.) Also, wie schaffe ich es nun diese Werte zu verwenden? Auf der Browser-Seite wurde hier Abhilfe geschaffen. Durch einen Parameter, der jsonp heißt, kann man eine Funktion angeben die auf diesen JSON-Code angewendet werden soll:

 <script type="text/javascript" src="http://extern.server.com/Data/Param?jsonp=processData">
 </script>

Gibt man das so an, wird nun beim Einbinden das JSON-Objekt als Parameter der processData-Funktion übergeben. Also wenn z.B. das Objekt so aussieht:

{
  name : "data",
  dataType : "someExample",
  value : {
    intVal : "123",
    stringVal : "OneTwoThree"
  }
}

Dann würde die Funktion so aufgerufen:

processData({ name : "data", dataType : "someExample", value : { intVal : "123", stringVal : "OneTwoThree" } });

So weit so gut. Nun geht’s allerdings darum, fest zu stellen ob das denn auch wirklich so einfach funktioniert und wie man bestehendes REST Framework dafür umschreibt. Welche Probleme fallen mir ad-hoc ein?

  • Wie soll man mit Aufrufen umgehen, deren Parametern zu lang sind für GET-Requests? Etwas anderes wird ja hier nicht angeboten.
  • Mein üblicher Technologie-Pessimismus: Nichts funktioniert einfach so. Alles dauert länger als man sich das vorstellt. Außerdem lauert hinter jedem Eck eine undokumentierte Eigenheit die ihre Reißzähne in mein Gesäßfleisch hauen möchte.

Aber wie sieht mein Framework überhaupt aus? Es ist eine Ansammlung von Methoden die eine generische Funktion callAPI mit den nötigen Funktionsparametern aufrufen. Ein Callback ist bereits implementiert. callAPI verwendet intern jQuery mit der Methode ajax. Es sollte theoretisch also kein Problem sein, das ganze umzubauen. (Siehe dazu auch dataType von $.ajax.)

Nach etwas herum probieren musste ich dann erstaunt fest stellen, dass es auch praktisch so einfach geht. Selten passiert mir so etwas :-) . Im Code, der so ähnlich aussieht wie der folgende, musste ich nur dataType auf jsonp stellen und schon funktionierte es.

performAPICall : function( request, params, callback ) {
			var oParams = params == undefined ? {} : params;

			oParams[ 'request' ] = request; // contains the function
			oParams[ 'format' ] = "json";
			// some session params

			var url = myHost + "/api/rest/";

			$.ajax({
				url : url,
				dataType : 'jsonp',
				data : oParams,
				type : 'POST',
				timeout : 30000,
				success : function(data) {
				  	// some success logging
				},
				error : function(data) {
					// error handling
				}
			}).done(function(data) {
				  // some extra code			

				  callback(data);
			});
		}
Posted in javascript | Leave a comment

Spotify und Windows XP

Ich kam in den Genuss die Spotify-App an der ich gerade schreibe auch auf einem XP-Gerät testen zu müssen.

Woher bekomme ich so eines? Naja, ich hatte noch ein altes ISO zuhause herumliegen und startete sofort meine VirtualBox um es zu installieren.

Der Plan sah folgendes vor:

  1. Windows XP installieren
  2. Spotify installieren
  3. Shared Folder einrichten
  4. Auf dem Host-System einen Hardlink vom Repo-Ordner der App hin zum Shared Folder erstellen.
  5. Auf dem XP-System einen Hardlink vom shared Folder in die Eigenen Dateien erstellen um von dort dann die App zu testen.

Das ganze hört sich gut an, denn immerhin komme ich so in den Genuss meiner eingerichteten Entwicklungsumgebung und könnte es trotzdem in einem anderen System testen.

Zu dumm dass sich gleich zwei Probleme dagegen stemmten.

FSUTIL – es war mir unmöglich dieses verdammte Tool für Windows XP zu finden. Vermutlich hätte ich nach irgendwelchen Server-Tools für Windows 2003 suchen müssen. Die Idee kam mir allerdings erst beim Schreiben dieser Zeilen. Doch egal, kopierte ich halt immer die aktuelle Version vom Shared Folder innerhalb von Windows XP in die Eigenen Dateien.

Das war allerdings schon Problem 2. Anstatt dass sich Spotify dazu überreden lies von dort zu starten, kam einfach immer nur die Meldung appNotFound. Erst heute, also einen Tag später kam ich dem Problem auf die Spur.

Ich musste die ganze VM restarten, jetzt funktioniert’s. Warum? Ich weiß es nicht, es ging aber auf jeden Fall.

Posted in Uncategorized, javascript | Tagged , | Leave a comment

No na Hä – NetworkOnMainThreadException ohne Network

Schon gewusst? Code der in alten Versionen von Android problemlos funktioniert kann in neuen Versionen zum Absturz führen.

Da gibt’s so Exceptions wie die NetworkOnMainThreadException. Aber dass Code wie dieser dazu führen kann!?

  Gson gson = MyGsonFactory.getGson();

  @SuppressWarnings("unchecked")
  T model = (T)gson.fromJson(new InputStreamReader(params[0]), clazz);
  return model;

Ab in einen AsyncTask, natürlich einen der mit der launch-Methode ausgestattet ist und jetzt geht’s wieder …

Posted in Android | Tagged , | Leave a comment