Coding Dojo – der Trainingsraum für Entwickler

Definition: A Coding Dojo is a meeting where a bunch of coders get together to work on a programming challenge (the Code Kata). They are there to have fun and to engage in deliberate practice in order to improve their skills.

(Quelle: http://codingdojo.org/)

The Principles of a Coding Dojo
(extracted from the Laurent Bossavit’s Blog: bossavit.com/dojo/archives/2005_02.html)

  1. The First Rule
    One important rule about the Dojo is : At the Dojo one can’t discuss a form without code, and one can’t show code without tests. It is a design training place, where it is acknowledged that “the code is the design” and that code without tests simply doesn’t exist.
  2. Finding a Master
    The master can’t be a master of every forms. I feel quite at ease with recursive functions and list processing e.g. but I think I don’t know how to create even a simple web app. Fortunately, while it’s the first time they really deal with “tail-recursion” some practionners here have done professional web apps for years!
  3. Come Without Your Relics
    Of course, you know how to do it. You know how and why this code is better than that one. You’ve done it already. The point is to do it right now, explain it to us, and share what you learned.
  4. Learning Again
    In order to learn again something, we just have to forget it. But it’s not easy to forget something when you’re alone. It’s easier when we give our full attention to someone who just tries to learn it for the first time. We can learn from others mistakes as well as from ours if we listen carefully.
  5. Slow Down
    Learning something should force you to slow down. You can go faster because you learned some tricks, but you cannot go faster and learn at the same time. It’s OK, we’re not in a hurry. We could do that for years. Some of us certainly will. What kind of deadline will we miss if we spend four more weeks on this subject rather than on four different subjects? More precisely, when we reach the next plateau, is it because we went through the previous one, or is it just because we were flying over it?
  6. Throwing Yourself In
    At some time someone begins to master a subject and wants to approach another one. Those threatened by boredom should throw themselves first into a presentation. The goal is to get back to a good motivation level, ie. an acceptable level of difficulty.
  7. Subjecting To A Master
    If it seems difficult to you, look for other practitionners who can judge your code and could easily show something new about it to you. Ask again until the matter contains absolutely no more difficulty to you.
  8. Mastering A Subject
    If it seems easy to you, to explain it to other who find it difficult. Explain it again as long as they find it difficult.

(Quelle: http://codingdojo.org/)

Seit mehreren Monaten experimentieren wir mit Coding Dojos in der Firma. Nach jedem bisherigen Dojo haben wir etwas gelernt und diese Erkentnisse bei dem nächsten Session gleich angewendet: Wir haben sozusagen die Dojo-Finding-Kata gelöst und eine gute Lösung dafür gefunden, wie wir dabei das meiste lernen können.

Es gibt 2 Levels: für Anfänger und für weniger Anfänger, mit einem gemeinsamem Punkt: alle sind Softwareentwickler. Anfänger bedeutet: neu in der Welt der Tests und/oder neu in C#. Dadurch, dass wir sowohl C# als auch JavaScript-Dojos machen, werden wir uns mal den einen mal den anderen Schuch anziehen müssen ;). Durch diese Aufteilung sind wir in der Lage, eine passende Übung durchzuführen. Die Einladung geht an alle und es bleibt jedem selbst überlassen, zu entscheiden, bei welchem Level er/sie mitmachen möchte. Diese Selbst-Verpflichtung führt automatisch dazu, dass man es ernst.

Was die Form betrifft, haben wir mehrere Varianten ausprobiert:

  • Mit oder ohne Moderator: Erkenntnis: es muss einen Moderator geben, wenn man nicht will, dass der Abend in Frust und Streit endet 😉
  • mit Coder und Driver (Randori Modus): Erkenntnis: der Coder war gleichzeitig der Driver, der andere saß nur da und wartete auf seine ReiheThumbs-down-icon
  • mit Wechsel der Paare nach einer bestimmten Zeit: Erkenntnis: das mentale Ticken einer Uhr hat teilweise zu einer kompletten Blockade geführt. Warum soll man überhaupt einen Stopper verwenden? Niemand sagt einem bei der Arbeit: du hast 5 Minuten für diese Aufgabe sonst müssen wir die Firma schließen!!Thumbs-down-icon
  • ein Dojo für alle, unabhängig von Kenntnissstand: Erkenntnis: ein guter Entwickler, der in C# noch noch nicht so bewandert ist, hat genauso gute oder gar bessere Ideen, als die anderen bzw. braucht länger um den Syntax des Lösungsweges zu verstehen. Das kann dazu führen, dass man sich unterschätztThumbs-down-icon

Nach verschiedenen Diskussionen mit anderen Entwickler, die Dojos in Unternehmen erfolgreich etabliert haben (danke nochmal Ralf und Uli) und nach diesen eigenen Erfahrungen, haben wir uns für die folgende Variante entschieden:

  • die Tastatur geht herum, und nicht der Entwickler (das hat auch immer wieder zu Störungen geführt).
  • Jeder, der dran ist, muss entweder den allerersten Test schreiben oder den vorherigen lösen: das bedeutet, er muss den Code schreiben, wodurch der Test grün wird – nicht mehr und nicht weniger. Danach muss er noch den nächsten Test schreiben, und zwar so, dass er rot ist. (Es gab Fälle, wo die nächste Anforderung – also der nächste Test – gleich mit implementiert wurde.)
  • Es gibt keine zeitliche Begrenzung und niemand muss alleine grübeln. Wenn Fragen oder Mißverständnisse im Raum stehen, sie werden sofort geklärt. Die Fragen müssen trotzdem vom Entwickler formuliert werden: der Lernprozess ist immer da.
  • Der Weg ist das Ziel: wird eine Aufgabe nicht in der Zeit erfüllt, die uns zur Verfügung steht, dann ist das auch ein Erkenntniss, aus dem man lernen kann.

Thumbs-up-icon

Wir verfolgen durch diese Trainingsstunden verschiedene Ziele:
– lernen, wie man Tests schreibt, um eine nachhaltige Qualität abzusichern,
– lernen, wie man Features gegen Code-Veränderungen schützt.
– lernen, wie man eine Anforderung interpretiert,
– lernen, wie man eine Anforderung definiert,
– lernen, wie man eine konstruktive Diskussion führt um sich auf eine Lösung zu einigen,
– lernen, wie man SOLIDen Code schreibt, Abhängigkeiten erkennt und trennt, wie man für Menschen lesbaren Code schreibt.

Die Liste der Lerneffekten solcher Übungen ist sicher viel länger, aber vorerst reicht es, wenn wir das hier schaffen :). Diese Prozesse werden sich sicherlich ändern – genauso wie wir Entwickler. Die Grundlagen aber bleiben bestehen: alles, was wir hier lernen, soll sich – wird sich –  in der täglichen Arbeit wiederspiegeln und uns zu besseren Softwareentwickler und gleichzeitig zu besseren Teamplayer machen.

Regions or no regions – this is the question

Die dnc12 ist gerade vorbei und wir könnten uns schon wieder zusammensetzen 🙂
Heute gab es auf Twitter eine kurz angerissene Diskussion, die das Zeug dazu hatte, die Gemüter aufzuheizen: soll man oder soll man nicht #regions nutzen?

 

Nach dem kurzen Tweet-Austausch wurde es klar, dass es viele Entwickler gibt, die Regions gerne nutzen. Ich habe zwar den ganzen Abend nachgedacht, habe allerdings keine Gründe gefunden, sie selbst verwenden zu wollen.

 

Ich meine, warum sollte man Code NICHT sehen wollen?

  • Geht es vielleicht um eine oder mehrere Methoden, die man ausblenden will? Das würde aber entweder bedeuten, dass man
    – die Funktionalität der ganzen Klasse ausblendet, aber dann wozu, man öffnet einfach die Klasse nicht 😉
    – nur ein Teil der Funktionen ausblendet, und dann stellt sich die Frage, warum manche Funktionen viel öfter angeschaut werden als andere? Das hat für mich irgendwie ein CodeSmell
  • Geht es vielleicht um ein Teil einer einzigen Methode, und zwar einer ganz großen, sonst würde man sie nicht teilweise ausblenden wollen? Zusammengeklappt würde man dann eine Art Kommentar sehen, was mich sofort an Martin Fowlers Hinweis bezüglich Kommentare erinnert hat: Kommentare sind ideale Namensgeber. Wenn man im Code einen Kommentar braucht, dann ist das meistens ein Smell für ein Extract Method (genauso wie die Tatsache, dass die Methode wahrscheinlich zu lang ist)

    You have a code fragment that can be grouped together.

    Turn the fragment into a method whose name explains the purpose of the method.

  • Geht es vielleicht um Regionen um Methoden, Events, Fields, Properties, also nach Sichtbarkeit und Rolle? Dafür könnte ich einen einzigen Grund vorstellen, und zwar den, dass man auf Anhieb die öffentliche Methoden und Eigenschaften sehen will. Das wäre allerdings die Aufgabe eines Interfaces, oder? Dazu kommt auch noch meine – persönliche – Vorliebe, Code wie ein Buch zu lesen, von oben nach unten, also von einer öffentlichen Methode weiter in die Details, also zu den privaten Methoden (ganz nach CCD – Single Level of Abstraction (SLA))

    Hilfreich als Analogie ist der Blick auf Artikel in der Tageszeitung: dort steht zu oberst das Allerwichtigste, die Überschrift. Aus ihr sollte in groben Zügen hervorgehen, wovon der Artikel handelt. Im ersten Satz des Artikels wird dies auf einem hohen Abstraktionsniveau beschrieben. Je weiter man im Artikel fortschreitet, desto mehr Details tauchen auf. So können wir auch unseren Code strukturieren. Der Name der Klasse ist die Überschrift. Dann folgen die öffentlichen Methoden auf hohem Abstraktionsniveau. Diese rufen möglicherweise Methoden auf niedrigerem Niveau auf, bis zuletzt die “Bitpfriemelmethoden” übrig bleiben. Durch diese Einteilung kann ich als Leser der Klasse entscheiden, welchen Detaillierungsgrad ich mir ansehen möchte. Interessiert mich nur grob, wie die Klasse arbeitet, brauche ich mir nur die öffentlichen Methoden anzuschauen. In ihnen wird die Funktionalität auf einem hohen Abstraktionsniveau gelöst. Interessieren mich weitere Details, kann ich tiefer einsteigen und mir die privaten Methoden ansehen.

Was meint ihr, übersehe ich da was? (Notiz an mich: bei #nossued das Gespräch fortsetzen!)

Sind Unit Tests wirtschaftlich untragbar?

Immer wieder höre ich die Aussagen “Unit Tests sind schön und gut, wir haben nur keine Zeit dafür.” Oder “Klar, man kann Tests machen, hauptsache, es nimmt nicht zu viel Zeit von der Arbeit weg” ??!!

 

Nur um Missverständnisse zu vermeiden: Tests macht man nicht zum Spaß oder aus Langeweile, die Tests stellen die Essenz, die abstraktester Form der Lösung dar!

 

Ich habe bis heute Schwierigkeiten damit, meinem Gegenüber zu erklären, dass er sich irrt. Ich WEIß es einfach aus Erfahrung, dass dies eine Milchmädchenrechnung ist. Keine ernsthafte Argumente gegen Tests würden bei einer tieferen Überprüfung standhalten. Die Pros übertreffen klar die Kontras. Aber wie soll ich etwas – für mich – Offensichtliches in Worte fassen? Wie soll ich etwas in ein paar Sätzen erklären, was ich in einem andauernden Prozess durch jeden NICHT (oder nicht richtig) geschriebenen Test gelernt habe? Oder durch jeden Aha-Effekt oder durch jeden stressfreien Release (kein Stress entsteht, wo kein Platz für Bugs existiert 😉 )

 

Unit Tests sind für den Open Mind “selbsterklärend”: wenn der Bug in einem ungetesteten Code steckt, dann wird das zu einer “blinden” Fehlersuche führen, die Tage dauern kann und auf jedem Fall Geld und Ruf kostet. Wie lange dauert es, den Fehler in einem getesteten Codebasis zu finden, wo die Eingrenzung innerhalb von Sekunden erfolgt? Wie oft kommt es überhaupt vor, dass dieses Problem entsteht? Für mich schaut die Rechnung so aus:

 
Zeit_für_fehlersuche = Unproduktive_Zeit;
f(Unproduktive_Zeit) = Verschwendetes_Geld;
 
0->Zeit_für_fehlersuche(getesteter_Code)----------------------->Zeit_für_fehlersuche(ungetesteter_Code)---.....oo
 

Ok, ich glaube, ihr kennt jetzt meinen Standpunkt 😉 Aber ich bin ja nicht die ultimative Maßstab dafür, wie man arbeiten sollte. Deshalb habe ich ein paar Artikel und Statistiken von klügeren Leuten zusammengesucht, bitte liest die auch.

 

Diese Infos habe ich bei stackoverflow gefunden:

Realizing quality improvement through test driven development: results and experiences of four industrial teams und hier eine Diskussion darüber.

The study and its results were published in a paper entitled Realizing quality improvement through test driven development: results and experiences of four industrial teams, by Nagappan and research colleagues E. Michael Maximilien of the IBM Almaden Research Center; Thirumalesh Bhat, principal software-development lead at Microsoft; and Laurie Williams of North Carolina State University. What the research team found was that the TDD teams produced code that was 60 to 90 percent better in terms of defect density than non-TDD teams. They also discovered that TDD teams took longer to complete their projects—15 to 35 percent longer.

“Over a development cycle of 12 months, 35 percent is another four months, which is huge,” Nagappan says. “However, the tradeoff is that you reduce post-release maintenance costs significantly, since code quality is so much better. Again, these are decisions that managers have to make—where should they take the hit? But now, they actually have quantified data for making those decisions.”

Es gab auch kleinere Experimente dazu wie z.B. Code Lab – TDD vs. Non-TDD

Over 3 iterations, average time taken to complete the kata without TDD was 28m 40s. Average time with TDD was 25m 27s. Without TDD, on average I made 5.7 passes (delivering into acceptance testing). With TDD, on average I made 1.3 passes (in two attempts, they passed first time, in one it took 2 passes.)

Now, this was a baby experiment, of course. And not exactly laboratory conditions. But I note a couple of interesting things, all the same.

Und weil ein Bild mehr als tausend Worte spricht: Die Kostenverteilung bei getesteten Code schaut ungefähr so aus
Testing Benefits

Tests schreiben ist einfach, der Ertrag ist riesig. Warum soll man also keine Tests schreiben? Sind wir wirklich unfehlbar, schreiben wir immer den perfekten Code? Seien wir mal ehrlich…Ich bin es sicher nicht und ihr auch nicht.

 

Und hier noch die obligatorische Buchempfehlung: The Art Of Unit Testing Das Buch ist wunderbar verständlich geschrieben mit echten Beispielen und guten Argumenten, warum und wie man testen soll.

Templating mit Razor aber ohne MVC

Ich habe unlängst nach einer Möglichkeit gesucht, Seiten schnell und effektiv zu generieren, sowohl für Web als auch für E-Mails als Background-Jobs. Ein Kollege hat mich auf @razorengine aufmerksam gemacht und diese Templating Engine scheint alles zu bieten, was ich gesucht habe.

A templating engine built upon Microsoft’s Razor parsing technology. The RazorEngine allows you to use Razor syntax to build robust templates. Currently we have integrated the vanilla Html + Code support, but we hope to support other markup languages in future.

Die Installation ist so einfach wie möglich:

//mit NuGet:
Install-Package RazorEngine

Man muss danach nur noch die RazorEngine.dll und System.Web.Razor.dll referenzieren und das war’s.

 

Das Generieren von Seiten kann entweder direkt oder mit vorkompilierten Templates erfolgen:

[Test]
public void PageCanBeParsed()
{
   const string template = "Hello @Model.Name! Welcome to Razor!";
   var result = Razor.Parse(template, new {Name = "World"});

   Assert.That(result, Is.EqualTo("Hello World! Welcome to Razor!"));
}
//unterstützt anonyme Klassen
[Test]
public void PageCanBeParsedWithCompiledTemplate()
{
   const string template = "Hello @Model.Name! Welcome to Razor!";
   Razor.CompileWithAnonymous(template, "world");
   var result = Razor.Run(new {Name = "World"}, "world");

   Assert.That(result, Is.EqualTo("Hello World! Welcome to Razor!"));
}
//oder konkrete Typen
[Test]
public void TemplateIsCompiledWithModelType()
{
   const string template = "Hello @Model.Name! Welcome to Razor!";
   var testModel = new TestModel{ Name = "World" };
   Razor.Compile( template, typeof(TestModel), "world2" );
   var result = Razor.Run(testModel, "world2");
   Assert.That(result, Is.EqualTo("Hello World! Welcome to Razor!"));
}

public class TestModel { public string Name; }

Um ehrlich zu sein, ich habe noch keinen Grund gefunden, warum man nicht die vorkompilierte Variante nutzen soll. In diesem Fall wird das Template EIN MAL kompiliert und in Cache abgelegt. Ein Vergleichs- und Stresstest, in dem ich ein halbwegs komplexes Template 500-mal mit Razor.Parse bzw. mit Razor.Compile + Razor.Run aufgerufen habe, hat folgendes geliefert:

   Parse: 03:35.97 min
   Compile+Run: 00:00.63 min

Ich glaube, damit ist alles gesagt. Es sei denn, eine Zeile weniger gilt auch als Argument 🙄

 

RazorEngine unterstüzt fast alles, was Microsoft’s Razor in Views anbietet, wie zum Beispiel Helper-Methoden, Model-Definitionen direkt im Template oder partielle Views:

[Test]
public void EngineSupportsInlineHelper()
{
   const string template = @"@helper MyMethod(string name) {Hello @name}@MyMethod(Model.Name)! Welcome to Razor!";
   var testModel = new TestModel{ Name = "World" };
   var result = Razor.Parse(template, testModel);
   Assert.That(result, Is.EqualTo("Hello World! Welcome to Razor!"));
}

[Test]
public void EngineSupportsInheritsCommand()
{
   const string template = @"@inherits RazorEngine.Templating.TemplateBase
@helper MyMethod(string name) {Hello @name}@MyMethod(Model.Name)! Welcome to Razor!";
   var testModel = new TestModel{ Name = "World" };
   Razor.Compile(template, typeof(TestModel),"testModel");
   var result = Razor.Run(testModel, "testModel");

   Assert.That(result, Is.EqualTo("Hello World! Welcome to Razor!"));
}

[Test]
public void EngineSupportsSubtemplating()
{
    const string masterTemplate = "You are on www.yellow-brick-code.org!";
    Razor.Compile(masterTemplate, typeof(TestModel), "master");

    const string contentView = @"@inherits RazorEngine.Templating.TemplateBase
@helper MyMethod(string name) {Hello @name}@MyMethod(Model.Name)! Welcome to Razor!";
    var testModel = new TestModel{ Name = "World" };

    const string template = contentView + " @Include(\"master\")";

    Razor.Compile(template, typeof(TestModel), "testModelMaster");
    var result = Razor.Run(testModel, "testModelMaster");
    Assert.That(result, Is.EqualTo("Hello World! Welcome to Razor! You are on www.yellow-brick-code.org!"));
}

Und nun sind wir soweit, das Ganze im Web zu testen.

 

Die Engine funktioniert so, dass sie zur Laufzeit aus dem Template eine dll mit einem Zufallsnamen erstellt. Also wenn man die Engine im Web nutzen will, müssen noch ein paar Dinge getan werden:

  1. RazorEngine.Web.dll referenzieren
  2. Ein VirtualPathProvider in Global.asax.cs registrieren
    public class Global : System.Web.HttpApplication
    {
       protected void Application_Start(object sender, EventArgs e)
       {
          HostingEnvironment.RegisterVirtualPathProvider(new RazorVirtualPathProvider());
       }
    ...
    
  3. In Web.Config muss der BuildProvider registriert werden:
    <configuration>
    <configSections>
    <section name="razorEngine" type="RazorEngine.Configuration.RazorEngineConfigurationSection, RazorEngine" requirePermission="false" />
    </configSections>   <razorEngine factory="RazorEngine.Web.WebCompilerServiceFactory, RazorEngine.Web" /><system.web>
    <compilation debug="true" targetFramework="4.0">
    <buildProviders>
    <add extension=".csrzr" type="RazorEngine.Web.CSharp.CSharpRazorBuildProvider, RazorEngine.Web" />
    </buildProviders>
    </compilation>

So aufgerüstet kann man mit den Models und Templates beginnen. Man kann die Templates als html-Dateien speichern. Allerdings wenn man IntelliSense haben möchte, dann muss MVC3 auf den Rechner installiert und die Datei als cshtml gespeichert werden.

 

Das Beispiel hier ist über ein MasterHeader mit dem Anfang der Seite, ein MasterFooter mit dem Ende, beide eingebettet mit " @Include(\"master...\")" in Content. Die ganze Seite bekommt ein Objekt vom Typ Model zum Parsen. Alle Templates werden mit einem ITemplateFinder geladen.

...
ITemplateFinder templateFinder = new TemplateFinder(path);
Razor.Compile(templateFinder.GetTemplate("masterHeader.cshtml"), typeof(Model), "masterHeader");
Razor.Compile(templateFinder.GetTemplate("masterFooter.cshtml"), typeof(Model), "masterFooter");

var model = new Model
{
    PurchaseNo = "011313074142",
    Amount = "270.63",
    Date = "20110121"
};

var template = templateFinder.GetTemplate("Content.cshtml");
Razor.Compile(template, typeof(Model), "content");
var parsedTemplate = Razor.Run(model, "content");
context.Response.ContentType = "text/HTML";
context.Response.Write(parsedTemplate);

Bevor ihr was über Namen oder Verantwortlichkeiten was sagt: das Projekt wurde als Spike erstellt, und als solche hat seine Rolle  perfekt erfüllt 🙂 In Produktion würde ich das Kompilieren von statischen Templates in Application_Start verschieben und das ITemplateFinder sollte auf  jeden Fall Injected werden.

 

Ich muss mich bei den 2 Jungs, die das Projekt entwickeln, sehr bedanken, es war eine super Idee! Schaut es einfach an, die dll kann noch viel mehr.

NOS Süd – ein etabliertes Konzept

Man nehme 50 bis 80 engagierte Menschen, ein gemeinsames Thema (Softwareentwicklung rund um .NET), 4 oder 5 Räume mit vielen Stühlen und ein paar Steckdosen und Flipcharts oder Beamer, gebe ausreichend Kaffee und ein Versprechen auf ein späteres Bier dazu. Man gebe ihnen alle Freiheiten der Kreativität – und eventuell ein Paar Gadgets, da es vorwiegend um Männer geht 😉 – und lasse sie machen. Fertig ist das OpenSpace-Gericht, mit Erfolgsgarantie.

 

Nach ca. 60 Stunden werden alle NOS-Süd 2011 mit einem gefüllten “mentalen” Rucksack verlassen! Manche werden konkrete technische Fragen geklärt bekommen haben, manche werden in ihrem Vorgehensweisen bestätigt und manchen werde eine ganz neue Richtung aufgezeigt. Manche lernen endlich die kennen, dessen (deren) Blogs sie seit langem lesen und manche werden aus der Anonymität “des einsamen Softwareentwicklers” herauskommen und sich als “Nerds” outen. Es werden Freundschaften gegründet und sicherlich auch künftige Geschäftsbeziehungen.

 

Und alle gehen müde und voll mit Tatendrang nach Hause, sich in der Community weiter zu engagieren und nächstes Jahr wieder zu kommen.

 

Das alles ist Open Space und gilt speziell für den .NET Open Space Süd, der an diesem Wochenende abgehalten wurde. Erstens war er schon für das zweite Mal in Karlsruhe, wo es bekanntermaßen immer schönes Wetter ist 😉 Zweitens waren da gerade so viele Menschen, dass keine Person und/oder Frage untergehen konnte. Aber das besondere “Salz” lieferten die Organisatoren dazu: Frank, Alex, Ralf und Aydin und all ihren großartigen Helfer. Es ist für mich immer wieder erstaunlich, wo sie die Zeit und Energie finden, das alles “so nebenbei” zu organisieren. Manchanderer findet nicht mal genug Zeit, zu einem User Group-Treffen hin zu gehen und die Jungs opfern ihre Freizeit dafür, uns diese jährliche Treffen zu organisieren. Nochmal DANKE dafür!

 

Ja, und nur zur Info: ich habe mir ein Twitteraccount eingerichtet 🙂

dotnet-cologne: veni-vidi-vici!

Am letzten Freitag fand die dotnet Cologne zum 3. Mal statt. Ich habe die ersten 2 Male nicht teilgenommen, aber wie ein Freund meinte, diesmal hatte ich “Heimvorteil” 🙂 Nach der langen Pause, bedingt durch Beinbrüche, Umzüge und ähnliche Erfahrungen, hatte ich regelrechte Entzugserscheinungen: Entzug von der Community.

Principles, patterns, and practices are important, but it’s the people who make them work. – Robert C. Martin aka Uncle Bob

Es war super! Über 300 Leute, darunter sehr-sehr viele bekannte Gesichter, riesen Freude sie wieder zu sehen. Der erste Vortrag, den ich besucht habe, hieß “Agile Architekturen” und wurde von Ilker abgehalten. Er hat zwei konkrete Beispiele – die Hexagonale Architektur von Alistair Cockburn und Data Context Interaction, der “neue MVC” – vorgestellt, samt Fallbeschreibung und Code für jeweils ein User Case. Wir dürften/sollten uns dann eine Meinung über die Lösungen bilden und diese Meinung auch kundtun. Es wurde schnell klar, dass jede Variante ihre Vor- und Nachteile hat, und dass die allgemein gültige “agile Architektur” nicht wirklich existiert.

 

Nach der Pause ging es dann für mich mit Daniel “REST Wars: WCF WebHTTP vs. ASP.NET MVC” weiter. Es war eine sehr interessante und kompetente Präsentation. Am Ende hatte ich eine ganz genaue Vorstellung darüber, WOZU man REST verwenden soll und welche technologische Möglichkeiten man hat. Notiz an mich: WCF WebAPI bei Codeplex anschauen.

 

Als Lunch-Session wollte ich unbedingt von Sergey über psake hören, aber die Zeit ist bei den Gesprächen mit den Jungs von User Group Karlsruhe irgendwie verflogen. Dafür habe ich stattdessen Kay Giza kennengelernt 🙂 Endlich kann ich ein Gesicht zu jener Person zuordnen, die mir seit Jahren regelmäßig Tipps und Empfehlungen schickt. Er hatte selbst eine Session über MSDN vorbereitet und ich hätte ihn sehr gern gehört, aber er war parallel mit der Azure-Session und an dieser musste ich auf jedem Fall teilnehmen. Also hat Kay meine Fragen zum MSDN zwischen a flying coke ( 😉 you know what I mean) und einen Kaffee im Foyer beantwortet. Danke schön 🙂

 

Der “Überflieger” des Tages war eindeutig Bart de Smet – der Mann, der in seiner Freizeit u.a. Sudoku mit c# (Stichwort Microsoft Solver Foundation) löst.
Ich konnte leider nur den ersten von 2 Vorträgen besuchen, über “LINQ to Everything” – und das hat er wirklich wortwörtlich gemeint. (Stichwort IQbservable, IScheduler)

 

Der vorletzte Vortrag war der bereits erwähnte “Azure: Portierung einer Anwendung”. Wir haben einen kleinen Überblick von der Zusammensetzung von “the Cloud” bekommen, und die “Do’s and Dont’s” dazu. Und mir wurden diese zwei Tatsachen klar: in der Cloud alles kostet Geld und ohne Clean-Code (insbesondere ohne Dependency Injection) braucht man darüber gar nicht nachzudenken. Wenn aber die Vorbedingungen erfüllt sind, dann geht das Portieren super schnell und einfach.

 

Last but not least habe ich mir eine Session über “Rich-Internet Apps & Mobile Anwendungen mit HTML5…” gegönnt, ein Thema, mit dem ich mich zur Zeit nicht direkt beschäftigen muss – zur Entspannung so zusagen 😉 Also dies war eine super Entscheidung, Tim Fischer ist ein großartiger Vortragender! Als Nebeneffekt habe ich erfahren, wie man JavaScript-Code ohne es zu schreiben generiert (Stichtwort Sencha) und was hinter dem Begriff HTML5 steckt.

 

Damit war für mich das Pflichtprogramm zu Ende, aber natürlich nicht der Tag.
Jeder, der bei solchen Community-Events schon teilgenommen hat, weiß, dass die besten Gespräche rund um Entwickler-Sein bei dem/den abschließenden Bier/en danach geführt werden. So hatte ich die Ehre, endlich codemurai kennen zu lernen und die Meinungen der anderen über Themen wie “warum ist Softwareentwicklung einer Männerdomaine” oder “Absatzmarkt China” oder “das Geheimniss hinter dem Erfolg von osteuropäischen Softwareunternehmen” zu hören.

 

Es war schön, es war anstrengend und es war sehr lehrreich.
Genauso, wie eine Konferenz sein soll.

 

Tausend Dank an das Orga-Team und an die Sprecher für ihre großartige Arbeit und für ihre Mühe, diese Community zu stärken und zu pflegen.
“Individuals and Interactions over Processes and Tools” – wie das Agile Manifest es so schön definiert – weil wo wären wir, wenn das nicht war wäre?!

 

Das nächste Event – NOS Süd 2011 – wartet schon…

Design copy-paste

www.codekicker.de
Irgendwann Anfang Februar habe ich von Marco Parrillo (Neue Mediengesellschaft Ulm mbH) eine Empfehlung für: “codekicker.de – Die deutschsprachige Entwickler-Community | Machen Sie mit!” bekommen. Ich finde so was immer super und habe die E-Mail sofort an meinen Kollegen weitergeleitet (die Empfehlung kam ja von einer seriösen Gesellschaft).

Ich hatte in der Arbeit keine Zeit, also habe ich die Seite erst am Abend geöffnet :
www.stackoverflow.com

Oh, dachte ich, super: eine deutsche Tochter von stackoverflow!

Auf den ersten Blick konnte man das nirgendwo sehen, also habe ich alles durchsucht: Impressum, Kontakte, sonstige Infoseiten, aber gar nichts… Danach habe ich einfach die Suchfunktion benutzt, aber das einzige Ergebnis eine Frage zu einem Stackoverflow-Exception war.

Durch googeln bin ich fündig geworden: die Seite ist gar keine Tochterseite von stackoverflow, sie wurde einfach nur kopiert! Auf die Suchbegriffe stackoverflow + codekicker habe ich folgende Diskussion bei stackoverflow gefunden:

In germany a Stackoverflow-like site was created, that is very, very similar to Stackoverflow in the mechanics of reputation and badges etc. That is so similar, that I think they could use the same software. Did you sell it to them? Or are they using a very similar clone-software? The Community I have in mind is Codekicker.

Das war ernüchternd (und gleichzeitig komisch, da es offensichtlich eine Diskussion auf codekicker über das Thema gibt, aber irgendwie doch nicht gefunden wird).
Als ich dann die Antworten der Betreiber der Seite gelesen habe, wurde ich richtig enttäuscht:

Vielen Dank für deine Anteilnahme an unserem Projekt 😉 Du darfst uns gerne auf unserer Feedbackseite gründlich deine Meinung sagen. Per Mail oder Telefon bin ich heute den ganzen Tag zu erreichen.

Gruß,
Marvin

Irre ich mich, oder waren die 2 Studenten sogar stolz auf ihre copy-paste Fähigkeiten? Und kann es wirklich sein, dass alle das ok finden und keine daran was auszusetzen hat? Ich meine, sogar die Logos sind ganz ähnlich. Und auch, wenn stackoverflow den Code nicht patentiert hat, jemand hat sich ja richtig viel Mühe gemacht, das Design auszudenken, angefangen mit den Farben bis zum Gesamtbild.

Die Antworten variierten zwischen “das macht ja nichts, Hauptsache ist es auf Deutsch” und “wenn es dir nicht passt, dann nutze es nicht!” – was für mich erst Recht keine Antwort ist.

Ich überlege nun seit ein paar Wochen, ob ich das hier ansprechen soll, aber ich möchte eure Meinung wissen:

  1. Bin ich wirklich die einzige, die diese Tatsachen stören? Wäre es wirklich zu viel gewesen, irgendwo auf der Seite ein Dankeschön an stackoverflow auszugeben?
  2. Auch wenn das von 2 Studenten OK wäre, ist es auch in Ordnung, dass nun mehrere renommierte Zeitungen ihren guten Namen dazu geben?
  3. Ist es dann auch in Ordnung, dass diese Zeitungen mit einer kopierten Seite Geld machen wollen – da sie ja kräftig Werbung dafür machen? Und diesen Satz habe ich gar nicht verstanden: “mit codekicker.de ist am 1. Februar 2011 die neue deutschsprachige Community-Plattform für Entwickler gestartet”? Die Seite gibt es ja schon seit Juli 2009.

Eins ist sicher: ich empfinde großen Respekt gegenüber Jeff und Joel und die anderen von stackoverflow und ich finde, sie leisten großartige Arbeit (auch, wenn sie dies sicher nicht umsonst tun). Genauso einen Respekt habe hatte ich auch vor den Redakteuren dieser Zeitungen. Durch sie aber – da ich ihre Empfehlung weitergeleitet habe – habe ich nun auch eine Sache unterstützt, deren Betreiber es meiner Meinung nach nicht verdient haben. Mein Fehler, wird so bald sicher nicht wieder passieren.

File provided for Reference Use Only By Microsoft Corporation (c) 2007

Seit ein paar Wochen, wenn ich mit Resharper zu der Implementierung von manchen Microsoft-Funktionen navigieren will, bekomme ich die ganze dll heruntergeladen und danach den ganzen Code zu sehen:

// ==++==
//   Copyright (c)  Microsoft Corporation.  All rights reserved.
// ==--==
namespace System.Globalization {
    using System.Security.Permissions; 
    using System.Runtime.Serialization; 
    using System.Text;
    using System; 
    //
    // Property             Default Description
    // PositiveSign           '+'   Character used to indicate positive values.
    // NegativeSign           '-'   Character used to indicate negative values. 
    // NumberDecimalSeparator '.'   The character used as the decimal separator.
    // NumberGroupSeparator   ','   The character used to separate groups of 
    //                              digits to the left of the decimal point. 
    // NumberDecimalDigits    2     The default number of decimal places.
    // NumberGroupSizes       3     The number of digits in each group to the 
    //                              left of the decimal point.
    // NaNSymbol             "NaN"  The string used to represent NaN values.
    // PositiveInfinitySymbol"Infinity" The string used to represent positive
    //                              infinities. 
    // NegativeInfinitySymbol"-Infinity" The string used to represent negative
    //                              infinities. 
    // Property                  Default  Description
    // CurrencyDecimalSeparator  '.'      The character used as the decimal
    //                                    separator.
    // CurrencyGroupSeparator    ','      The character used to separate groups 
    //                                    of digits to the left of the decimal
    //                                    point. 
    // CurrencyDecimalDigits     2        The default number of decimal places. 
    // CurrencyGroupSizes        3        The number of digits in each group to
    //                                    the left of the decimal point. 
    // CurrencyPositivePattern   0        The format of positive values.
    // CurrencyNegativePattern   0        The format of negative values.
    // CurrencySymbol            "$"      String used as local monetary symbol.
    // 

    [Serializable] 
    [System.Runtime.InteropServices.ComVisible(true)] 
    sealed public class NumberFormatInfo : ICloneable, IFormatProvider
    { 

        // invariantInfo is constant irrespective of your current culture.

        private static NumberFormatInfo invariantInfo;
...

Das ist wunderbar, es ist großartig zu sehen, wie die Klassen Random or DateTime aufgebaut sind. Obwohl ich keine Ahnung habe, warum das passiert… Ich hoffe allerdings, dass es kein Bug ist, und ich weiterhin den Code statt irgendeine Dokumentation sehen werde, auch wenn komischerweise am Ende der meisten Klassen der Titel dieses Artikels steht: File provided for Reference Use Only By Microsoft Corporation (c) 2007 😉

Das alles ist cool, aber noch nicht wirklich ein Grund für einen Blogeintrag. Den folgenden Kommentar wollte ich euch aber nicht vorenthalten:

        // READTHIS READTHIS READTHIS 

        // This class has an exact mapping onto a native structure defined in COMNumber.cpp

        // DO NOT UPDATE THIS WITHOUT UPDATING THAT STRUCTURE. IF YOU ADD BOOL, ADD THEM AT THE END. 

        // ALSO MAKE SURE TO UPDATE mscorlib.h in the VM directory to check field offsets. 

        // READTHIS READTHIS READTHIS

        internal int[]  numberGroupSizes = new int[] {3};
...
        internal bool m_useUserOverride=false;    // NEVER USED, DO NOT USE THIS! (Serialized in Everett)
...

😆

Recht auf benutzerfreundliche Software

Bei den letzten DNUGKöln-Treffen habe ich einen verblüffenden Satz gehört:

Jeder Bürger hat ein streitbares Recht auf benutzerfrendliche Software.

Die Grundlage wird durch die Bildschirmarbeitsverordnung (BildschirmarbV, Dezember 1996) geliefert. Die Liste der Anforderungen an den Bildschirmarbeitsplätzen beinhaltet folegende Punkte:

21.
Bei Entwicklung, Auswahl, Erwerb und Änderung von Software sowie bei der Gestaltung der Tätigkeit an Bildschirmgeräten hat der Arbeitgeber den folgenden Grundsätzen insbesondere im Hinblick auf die Benutzerfreundlichkeit Rechnung zu tragen:
21.1
Die Software muß an die auszuführende Aufgabe angepaßt sein.
21.2
Die Systeme müssen den Benutzern Angaben über die jeweiligen Dialogabläufe unmittelbar oder auf Verlangen machen.
21.3
Die Systeme müssen den Benutzern die Beeinflussung der jeweiligen Dialogabläufe ermöglichen sowie eventuelle Fehler bei der Handhabung beschreiben und deren Beseitigung mit begrenztem Arbeitsaufwand erlauben.
21.4
Die Software muß entsprechend den Kenntnissen und Erfahrungen der Benutzer im Hinblick auf die auszuführende Aufgabe angepaßt werden können.

Das erste, was mir – und ich bin sicher, nicht nur mir – in Sinn gekommen ist, war: wie zum Teufel konnte Windows dieser Verordnung entsprechen?? Ich denke dabei vor allem an Punkt 21.3 …

Am Ende des vorher erwähnten Satzes, gab es allerdings noch eine Bemerkung: “es weißt nur keiner“.

Also jetzt schon.

Off Topic: In dieser Liste gibt es noch einen letzten Punkt:

22.
Ohne Wissen der Benutzer darf keine Vorrichtung zur qualitativen oder quantitativen Kontrolle verwendet werden.

Und jetzt frage ich mich, ob all die Konzerne (Deutsche Bahn, Telekom und wie die alle heißen), die ihren Mitarbeiter ausgespitzelt haben, wirklich dieser Anforderung entsprechen…

40 Jahre – 1600 Kilometer

public static void Main(Events e)
{
    Wenn( e == als Steinbock-Mädchen in einer ungarischen Familie in Rumänien geboren)
    {
       Glücklich aufwachsen
       Ein glücklicher/in einer Diktatur dem Establishment trotzender Teenager sein 
//ohne Diktatur kann man ja nicht so gut trotzen

       /*
       Testlauf für eine Partnerschaft, Akzeptanzkriterien nicht erfüllt, Feature verworfen
       */

       Wenn( e == bei der einzig blutigem Umsturz in Europa in der vordersten Reihe stehen)
       {
            Schätzen lernen, was man hat und was man erkämpft hat.
            Die ersten "Communities" mitgründen
       }
       Wenn(e == !( Fließbandarbeiter von 7 bis 15 Uhr sein wollen ) )
       {
            Eine Uni für Maschinenbau - Fahrichtung Schienenfahrzeuge besuchen
            Coole Sachen erleben // Züge selbst fahren, z.B.
       }
       sonst
       {
           // else gibt es nicht!
       }

       Wenn(e == das beste Model "Ehemann" gefunden && Typeof(e) == Typeof(Ehemann) && e.Land == "Deutschland")
       {
           Alles neu Anfangen // Sprache, Land, Stadt ... Leben
           Wenn(Recht für ein neue Ausbildung durch Zeitarbeit erarbeitet)
           {
                Sich in die Anwendungsentwicklung-Umschulung stürzen, alles lernen, was nur geht.
                Wenn( fertiggelernt )
                      9/11 => IT-Markt absturz // wie auch sonst alle Arbeitsmärkte

               Weitere Sachen lernen // wie. z.B. Lotus Notes
                Wenn(e == Job finden)
                {
                      Noch mehr lernen.
                      Job als Hobby und Hobby als Job definieren.
                      Community beitreten!
                      Noch VIEL mehr lernen.
                }
           }
           Wenn(e == es reicht, den Ehemann nur 3 Tage die Woche zu sehen, da er Consultant || TimeSpan > 6 Jahre)
           {
                 Neuen Job in Köln suchen //Stadt durch zweite Parameter vorgegeben
                 Sleep(7 Wochen) //Wegen ungeplanntem Beinbruch
                 super Job + super Kollegen + tolle Freunde + wunderbare Stadt + geniale Wohnung 
//Wetter könnte besser sein ...

                 Do
                 {
                      continue;

                 } while ( true );
           }
     }
}