Thomas Trotzki, ein Kollege von mir, führt im Auftrag von Microsoft die C++ Days durch. Es gibt noch vereinzelt Plätze. Wer also mit C++ arbeitet dem sei diese Veranstaltungsreihe wärmstens empfolen.

C++ geht mit der Zeit – gehen Sie mit! Wir zeigen Ihnen die Neuerungen und Trends in der Microsoft C++-Welt, von neuen Sprachfeatures über effektive Parallelisierung bis hin zu professionellem Software Engineering durch Application Lifecycle Management. Termine gibt es in Berlin, Bad Homburg, Karlsruhe oder Köln. Die Teilnahme ist natürlich kostenlos, aber die Plätze sind begrenzt.

Zugegeben: In den letzten Jahren waren die Neuerungen rund um die „managed“ .Net-Programmierung mit einschlägigen Sprachen wie C# im Fokus der Aufmerksamkeit. So ist .Net zu einer der produktivsten Entwicklungsplattformen gewachsen.

Doch C++ ist zurück im Rampenlicht: Auch im 21. Jahrhundert wird C++ als Programmiersprache nicht weg zu denken sein. In C++ können Sie stets selbst zwischen Performance und Abstraktion wählen. Kein unnötiger Overhead, bei Bedarf volle Kontrolle. Und genau das wird C++ auch in der Zukunft seinen Platz unter den Programmiersprachen sichern – der Trend immer komplexere Anwendungen auf immer kleinere Hardware zu bringen unterstützt dies nachhaltig.

Seit Visual Studio 6.0 hat sich auch in der Microsoft C++-Welt viel getan –also höchste Zeit für ein Wissens-Update.

Wo? Wann?

2.2.2012 14:00- 18:00 Berlin: ANMELDUNG
7.2.2012 14:00- 18:00 Bad Homburg: ANMELDUNG
13.2.2012 14:00- 18:00 Karlsruhe: ANMELDUNG
5.3.2012 14:00- 18:00 Köln: ANMELDUNG
Teilnahme: Kostenlos

Der C++ Day 2012 wird freundlicherweise unterstützt von artiso.

Folgende Themen erwarten Sie:

C++ 11: Modernes C++ im 21. Jahrhundert

C++ bleibt aktuell – neue Sprachfeatures machen den nativen Klassiker fit für neue Herausforderungen. Dieser Vortrag gibt Ihnen einen Überblick über die wesentlichsten Neuerungen in C++ 11 – wie beispielsweise Smartpointer mit Reference-Counting (shared_ptr), Lambda-Expressions, neue Container-Klassen, Iteratoren und Sprachkonstrukte wie for_each sowie RValue References.

Parallel-Power in Visual Studio 11: Konzepte und Tools

Effektive parallele Programmierung erhöht die Performance in vielen Fällen drastisch, braucht aber das richtige Know-How und spezialisierte Tools. Denn bei stetig steigender Anzahl an Cores und CPUs wird es immer wichtiger, das Anwendungsmodell in Richtung Skalierbarkeit hinsichtlich Multiprocessing auszulegen. Auch das Debugging bietet einige Herausforderungen. Verschaffen Sie sich einen Überblick über die neuen Konzepte rund um Parallelisierung in Windows API, Concurrency Runtime und Visual Studio.

Application Lifecycle Management für C++: Die nächste Generation

Application Lifecycle Management ist mittlerweile auch in der nativen Entwicklung Pflicht: Mit Team Foundation Server haben Projektteams jeder Größe ein zentrales Portal für Zusammenarbeit, Versionskontrolle, Work Item Tracking, Build-Management, Prozessunterstützung und Fortschrittsreports . Dies ermöglicht den Mitgliedern von Teams, besser und effizienter zusammenzuarbeiten. Der Haken bisher: Die wichtigsten Features wurden auch für C++ unterstützt, aber bestimmte interessante Features waren der .NET Welt vorbehalten. Die gute Nachricht: Visual Studio 11 zieht hier nun nach – sehen Sie, welche Neuerungen sie erwarten.

Der Referent

Thomas Trotzki ist ALM Consultant bei der artiso AG nahe Ulm und Microsoft-C++-Profi der ersten Stunde.

Mit Microsoft C++ und den MFC beschäftigt er sich intensiv seit den ersten Beta-Versionen zu Microsoft C/C++ 7.0, also bereits vor der Geburtsstunde von Visual C++ und Visual Studio.

Technologisch ist er neben C++ und den MFC auch mit COM/DCOM und der gesamten „Managed Welt“ vertraut und hat umfangreiche Expertise im Application Lifecycle Management. Zurzeit betreut er Kunden bei der Einführung von Microsoft Team Foundation Server und berät bei der Etablierung eines Application Lifecycle Management in deren Entwicklungsabteilungen.

Auf den ALM Days 2011 am 23.11 werde ich einen Workshop anbieten zum Thema “Scrum mit TFS”. Dabei werde ich zeigen, wie man mit dem TFS Scrumm effizient umsetz, welche Tricks es gibt um bestimmte Szenarien abzubilden und wie Visual Studio 2010 und TFS dabei helfen können Herausforderungen bei agiler Entwicklung zu lösen.

Abstract: Agilität ist in und wer agil sagt, meint fast immer Scrum. Die Konzepte die hinter Agilität stehen versprechen nicht nur effizientere Projekte sondern auch motiviertere Teams mit mehr Spass am Entwickeln. Wer mit Scrum arbeitet steht vor der Wahl, entweder ein Teamboard einzurichten auf dem Artefakte mit Zetteln verwaltet werden oder auf ein Tool zu setzen um die Artefakte elektronisch abzubilden. Der Workshop zeigt, wie sie mit dem TFS Scrum effizient abbilden und dabei die eine oder andere Hürde überwinden. Dabei wird nicht nur auf den Planungsprozess eingegangen sondern es wird auch aufgezeigt, wie Visual Studio 2010 und der TFS verschiedene Herausforderungen im Bereich der agilen Entwicklung wie z.B.agiles Testing lösen. Kurzum, dieser Workshop ist für jeden ein Muss der mit dem TFS arbeitet und agiler werden möchte oder der Scrum einsetzt und sich eine passende Toolunterstützung wünscht.

Weitere Infos unter http://www.teamconf.de/workshops/articles/ganztagesworkshop-1-mein-tfs-kann-scrum-wie-der-tfs-effizient-mit-scrum-genutzt-werden-kann.html

Auf der dotnet Cologne war ich dieses Jahr mit 2 Vorträgen vertreten, einmal mit dem TFS 2010 Quickstart wo ich innerhalb des Vortrags in einer Stunde live einen TFS installiert, die Versionsverwaltung und den Build eingerichtet, Requirements und Test Cases angelegt, Testfälle spezifiziert und ausgeführt, Bugs angelegt und die Traceability demonstriert. Im zweiten Vortrag habe ich verschiedene Best Practices zu SCRUM vorgestellt und die Umsetzung mit TFS vorgestellt. Es war wieder eine tolle Konferenz, vielen Dank an das Orga-Team.

Wer sich nochmals die Folien anschauen mag, hier sind die Links zum Download. Wenn es nachträglich noch Fragen gibt, dann könnt ihreuch gerne per Mail an mich wenden.

Dieses Jahr ist nach längerer Zeit die TechEd, die wichtigste Microsoft-Konferenz in Europa, wieder in Deutschland, genauer gesagt vom 09.Nov – 13. Nov in Berlin. Ich werde dort als ATE (Ask the Experts) zum Thema Visual Studio ALM vertreten sien und darüber hinaus mit Christian Binder und Neno Loje ein Q&A Session zu den Themen TFS, ALM und Visual Studio 2010 zu machen. Die Session wird in Deutsch sein, also wenn ihr Fragen rund um den Themenbereich habt, besucht unsere Q&A-Session. Soviel geballtes Wissen auf einmal gibts nicht so bald wieder

Visual Studio Team Foundation Server Q&A
Mittwoch, 11. November
14:00 – 15:00 Uhr
Community Stage im Zentrum der Ausstellung Halle 4.2

Die .net Developer Group Ulm bietet am 27.10.2009 eine kostenlose Ganztagesveranstaltung rund um Visual Studio 2010 ALM (vormals VSTS 2010). Die Nachfrage für diese Veranstaltung ist so hoch, dass wir uns entschieden haben, die Veranstaltung am 26. November nochmals mit gleichen Sprechern und gleichem Inhalt zu wiederholen. Wer also noch Interesse hat, sollte sich bald möglichst unter http://www.dotnet-ulm.de/vsts2010/ registrieren, wir haben noch ein paar Plätze frei.

Auf der diesjährigen ADC hatte ich zwei Vorträge:

• Effektive Prozesse durch Architektur
• Organisation von Entwicklerteams

Zu beiden Vorträgen gibt es die Unterlagen über den jeweiligen obenstehenden Link.

Letzte Woche habe ich bei der .Net Developer-Group Ulm einen Vortrag zum Thema “10 Gründe warum Software-Projekte fehlschlagen – und was hilft ALM"?” gehalten. Es gab zu diesem Vortrag eine reihe interessanter Diskussionen. Die Folien gibt’s hier zum herunterladen:

Bei der TeamConf handelt es sich um eine Konferenz mit dem Focus auf Themen rund um VSTS und TFS. Da durfte ich natürlich nicht fehlen

Leider war mein Vortrag der letzte der Konferenz und dazu noch parallel zum VSTS 2010 Vortrag von Christian Binder. Dennoch fand sich eine interessierte Runde zum Thema “Requirements Management in leichtgewichtigen Prozessen” zusammen. Hier noch meine Folien zum Download:

Im zweiten Teil wurde anhand eines kleinen Demos die konkrete Implementierung von WCF-Anwendungen erläutert. Es wurde ein Chat-System auf Basis der WCF erstellt. Das Demo gibt es hier zum Download. Außerdem möchte ich hier noch auf eine Einführung in die WCF hinweisen die man hier findet

Beim ersten Termin wurden die Grundlagen zu verteilten Anwendungen im allgemeinen und der WCF im speziellen vermittelt.

Gestern und heute hatte ich auf der BASTA zwei Vorträge. Hier die Folien dazu:

Ich bin reichlich spät dran, die VSOne ist schon seit einer Woche vorbei. Hier aber nun endlich meine Folien zu meinen Vorträgen

Zusammen mit Christian habe ich einen Webcast zum Thema Testing Practices aufgenommen. In dem Webcast werden zunächst verschiedene Testmethoden vorestellt und anschließend werden verschiedene Aspekte einer Teststrategie diskutiert wie z.B. Methoden zur Testfall-Ermittlung.

Der komplette Abstract lautet:

Qualität spielt in Software-Projekten eine immer größere Rolle. Ein wesentlicher Aspekt für Software-Qualität ist das Testen. Der Webcast stellt zunächst kurz die verfügbaren Testmethoden in Visual Studio vor und zeigt anschließend Aspekte einer Test-Strategie auf. Darüber hinaus wird die Integration mit dem Team Foundation Server kurz beleuchtet und es werden Methoden zur Testfallermittlung beschrieben.

Über ein Feedback zum Webcast würde ich mich freuen.

http://www.microsoft.com/germany/msdn/webcasts/library.aspx?id=1032405240

Beim nächsten Treffen der .Net Developer-Group Ulm dürfen wir diesesmal Dariusz Parys begrüßen, der zum Thema “Architektur der Datenanbindungsschicht, insbesondere ADO.NET Data Services und Entity Framework” spricht. Der Abstract verspricht schon mal einen sehr spannenden Abend:

LINQ to SQL, ADO.NET, Entity Framework, Entity Data Model, REST mit ADO.NET Data Services oder Serialisierung mit WCF ? – neben einem Überblick über die Alternativen und detailliertere Darstellung des Entity Frameworks wird darauf eingegangen, welche Kriterien beim O/R-Mapping zur Bewertung zur Verfügung stehen und diskutiert, welcher Nutzen darin liegt, die Datenanbindung von einer technischen Ebene auf eine logische zu heben.

Ích glaube das dürfte ein Themengebiet sein mit dem im Moment jeder Entwickler in irgendeiner Weise käpft und so dürfte sich Dariusz schon mal auf eine ganze Reihe von Fragen einstellen (Mir selbst fallen da schon eine ganze Reihe ein).

Wer also Interesse an dem Thema hat, ist herzlich eingeladen am Dienstag 17.02.2008 um 18:00 zu uns zu kommen.

Weitere Infos unter:

http://www.dotnet-ulm.de

In den letzten Wochen war ich recht viel mit Vorträgen auf Tour. Inzwischen hat sich eine stattliche Anzahl von Vortragsthemen angesammelt. Unten sieht man eine Übersicht. Wer Interesse hat, dass ich einen Vortrag halte, darf sich gerne bei mir melden. Über das INEATA Speaker Bureau bin ich für INEATA UserGroups auch kostenlos zu buchen. Ansonsten würde ich mich auch über Feedback freuen. Sollte ich noch ein Thema mit aufnehmen, wer hat schon einen Vortrag von mir gehört und wie hat er gefallen etc.

In der vergangenen Woche war ich bei gleich 3 User-Groups in Bonn, Stuttgart und bei uns in Ulm und habe dort meinen Vortrag zu architekturbasierten Entwicklungsprozessen gehalten. Dabei ging es im Kern darum, dass moderne Software.Projekte bestimmte Anforderungen an Prozesse haben. Der Vortrag zeigte hier zunächst verschiedene dieser Anforderungen an Testbarkeit, Team-Arbeit und die Definition von Spezifikationen. Anschließend wurden verschiedene Architekturkonzepte vorgestellt um dann aufzuzeigen, wie diese Konzepte die Prozessanforderungen erfüllen können. Zum Abschluss wurde dann das Ganze mit einem Demo-Projekt anschaulicher dargestellt.

Die Folien und das Demo kann hier heruntergeladen werden:

Zusammen mit Christian Binder habe ich auf der TechEd einen TechTalk zum Thema hierarchische Workitems aufgezeichnet. Das Video steht auf der TechEd Online Library unter http://msdn.microsoft.com/en-us/events/teched/cc561184.aspx zur Verfügung, oder alternativ einfach auf das Bild unten clicken.

Gestern Abend habe ich bei der .Net Developer Group Braunschweig einen Vortrag zu Agile Development Process - Ein architekturbasierter Entwicklungsprozess gehalten. Während des Vortrages und vor allem am Ende gab es eine sehr gute und interessante Diskussion.

Bei dem Vortrag habe ich demonstriert wie wir bei uns im Unternehmen verschiedene Architekturpatterns verwenden um Prozessanforderungen zu unterstützen. Dabei kommen bewährte Konzepte wie Komponentenorientierung, Contract First und mehrschichtige Architektur zum Einsatz, aber auch von uns angepasste bzw. neu entwickelte Methoden.

Die Folien und das Demo kann hier heruntergeladen werden:

Today I had my second talk on the TechEd in Barcelona. It was about closing tool gaps in development processes and using the TFS API. Thanks to all attendees joined my session. We had some very interesting discussion at the end, and I got a lot of positive feedback like “This was what I was looking for”. For all here comes the promised downloads for the slides and demos. Feel free to use them in either way.

And here the link to download WorkitemManager. At www.alm-tools.com you can download the Open version which is free and also the source code. And if you are interested in one of the tools I showed, please just send me an e-Mail to tschissler (at) artiso (.) com.

Ok, not to confuse you, I'm not going to blog English from now on. But I did a session on UI-Testsing with the UI Automation Framework and to provide slides and demo-code to the attendees I use this blog post. The session went fairly well from my point of view and I had some really interesting discussions on this topic after the session. I hope those who have joined me got some good information about how you can do UI-testing today with completely free tools.

I'll provide some pictures later because I cannot read them from my camera right now.

Here comes the downloads:

Christian Binder hat eine sehr Übersichtliche Darstellung über die verschiedenen VSTS-Sessions auf dem Technical Summit in Berlin zusammengestellt. Die Map stellt nicht nur die dort live vorgestellten Sessions zusammen, soondern auch bereits bestehende und in Kürze erscheinende Webcasts zu dem Thema. Die Map zeigt auch, dass wir versucht haben unsere Inhalte auf dem Technical Summit so aufeinander abzustimmen, dass sowohl EInsteiger als auch fortgeschrittene Anwender sich ein möglichst komplettes Bild von VSTS machen kann. Die WebCast sind thematisch entsprechend eingeordnet und können als Vorbereitung bzw. zur Vertiefung zu den Live-Sessions genutzt werden.

Danke Christian, endlich mal eine übersichtliche Darstellung der verschiendenen Inhalte! 

Was bedeutet was?

Christian Binder's Weblog : Alle Visual Studio Teamsystem Session auf dem Technical Summit 2008 im Überblick

Microsoft Research hat vor kurzer Zeit PEX zum freien Download veröffentlicht. Hinter diesem unscheinbaren Kürzel verbirgt sich ein Tool das absolut genial und beeindruckend ist und klar mach, warum Microsoft ein research center unterhält. Das Tool verspricht nichts weniger als die automatische Generierung von Unit-Tests und den dazugehörigen Testcases um eine möglichst hohe Code-Abdeckung zu erzielen. Detaillierte Informationen bietet das Whitepaper, wer sich auf die schnelle einen Einblick verschaffen möchte findet einen Überblick im Folgenden (na ja, für einen Überblick ist der Post vielleicht doch ein wenig lang geraden, aber ich konnte mich nicht bremsen vor Begeisterung):

Darf ich vorstellen - PEX

Gegeben sei folgende Methode die getestet werden soll:

   1: public string SimpleTest(int x1, int x2)

   2: {

   3:     if (x1 > x2)

   4:         return "x1 > x2";

   5:     if (x1 < x2)

   6:         return "x1 < x2";           

   7:     else

   8:         return "x1 == x2";

   9: }

Für das versierte Auge eines Entwicklers ist sofort klar, da brauchen wir 3 Testcases um eine vollständige Code-Abdeckung zu erzielen. Mal sehen, was PEX daraus macht. Zunächst mal muss PEX heruntergeladen und installiert sein.  Dann kann man einfach einen "Parameterized Unit Test Stub" erzeugen. Dazu in der Methode rechts klicken und den Befehl aus dem Pex-Menü auswählen.

Im folgenden Dialog können Sie verschiedene Parameter angeben. Das wichtigste hier ist das Testprojekt in dem der Stub erzeugt werden soll.

Der erzeugte Stub sieht dann so aus:

   1: /// <summary>

   2: /// This class contains parameterized unit tests for Calculation

   3: /// </summary>

   4: [TestClass]

   5: [PexClass(typeof(Calculation))]

   6: public partial class CalculationTest

   7: {

   8:     [PexMethod]

   9:     public string SimpleTest(

  10:         [PexAssumeUnderTest]Calculation target,

  11:         int x1,

  12:         int x2

  13:     )

  14:     {

  15:         string result = target.SimpleTest(x1, x2);

  16:         return result;

  17:         // TODO: add assertions to method CalculationTest.SimpleTest(Calculation, Int32, Int32)

  18:     }

  19:     

  20: }

Bei diesem Stub handelt es such um eine Vorlage für einen parameterisierten Unit-test. Toll, und was lässt sich damit nun machen? Wir können eine "Exploration" starten.

Diese Exploration versucht nun Input-Parameter zu finden die zu einer möglichst 100%igen Code-Abdeckung führen. Und hier beginnt nun die Magic von PEX. Ohne unser Zutun findet PEX 3 Kombinationen von Input-Parametern die tatsächlich eine komplette Code-Abdeckung erzielen- WOW! Dazu analysiert PEX wirklich den von uns erstellten Code und kann daraus definieren, mit welchen Input-Parametern die einzelnen noch nicht abgedeckten Zweige erreicht werden können.

Und das schönste, PEX baut uns automatisch 3 Unit-Tests die diese Testcases implementieren:

   1: [TestMethod]

   2: [PexGeneratedBy(typeof(CalculationTest))]

   3: public void SimpleTest01()

   4: {

   5:     string s;

   6:     Calculation calculation = new Calculation();

   7:     s = this.SimpleTest(calculation, 1, 2);

   8:     Assert.AreEqual<string>("x1 < x2", s);

   9: }

  10:  

  11: [TestMethod]

  12: [PexGeneratedBy(typeof(CalculationTest))]

  13: public void SimpleTest02()

  14: {

  15:     string s;

  16:     Calculation calculation = new Calculation();

  17:     s = this.SimpleTest(calculation, 1879212556, 1879212556);

  18:     Assert.AreEqual<string>("x1 == x2", s);

  19: }

  20:  

  21: [TestMethod]

  22: [PexGeneratedBy(typeof(CalculationTest))]

  23: public void SimpleTest03()

  24: {

  25:     string s;

  26:     Calculation calculation = new Calculation();

  27:     s = this.SimpleTest(calculation, 256, 254);

  28:     Assert.AreEqual<string>("x1 > x2", s);

  29: }

Diese Unit-Tests können wir nun starten und sehen, dass diese wie erwartet alle erfolgreich sind.

Damit haben wir einen Test automatisiert erstellt, der sicherstellen kann, dass diese Methode ihr Verhalten nach Außen für die aktuell definierten Test-Cases nicht verändert. Damit können ungewollte Änderungen an der Methode erkannt und beseitigt werden. Ob die Methode allerdings ihre Aufgabe korrekt erledigt, kann PEX natürlich nicht testen. Haben wir die Funktionsweise einer Methode allerdings einmal validiert, kann PEX nun sehr einfach dieses Verhalten prüfen. Und natürlich eignet es sich auch sehr gut um mögliche Test-Cases zu definieren. Es müssen in diesem Fall dann nur noch die einzelnen Ergebnisse je Test validiert werden.

Ändern wir die Methode ab, so dass sich ihr Verhalten ändert, dann alarmiert uns der entsprechende Test.

Soweit sogut - Und was geht sonst noch?

Wenn wir nun ein gewünschte Änderung der Funktionalität implementieren, wie kann PEX dann damit umgehen? Zunächst würden wir die vorhandenen Tests durchführen, damit wir sicher sind, dass die aktuelle Funktionalität noch korrekt läuft. Dann erweitern wir unsere Methode:

   1: public string SimpleTest(int x1, int x2)

   2: {

   3:     if (x1 > x2 * 2)

   4:         return "x1 > x2 * 2";

   5:     if (x1 > x2)

   6:         return "x1 > x2";

   7:     if (x1 < x2)

   8:         return "x1 < x2";           

   9:     else

  10:         return "x1 == x2";

  11: }

Schön - darf's noch ein bisschen mehr sein?

Dieses einfache Sample war ja schon sehr beeindruckend. Die Frage, die sich aber natürlich direkt stellt, ist wie weit geht denn das? Wir wollen nun den Schwierigkeitsgrad für PEX schrittweise steigern. Integer-Werte sind ja noch relativ einfach zu handhaben, aber wie sieht's denn beispielsweise mit Strings aus? Hierzu zunächst wieder eine Methode, die wir testen wollen:

   1: public class StringOperations

   2: {

   3:     public string CheckString(string Input)

   4:     {

   5:         if (Input.StartsWith("abc") && Input.Length > 10)

   6:             return Input + " Starts with 'abc' and length > 10"; 

   7:         if (Input.StartsWith("abc"))

   8:             return Input + " Starts with 'abc'";

   9:         if (Input.StartsWith("ABC"))

  10:             return Input + " Starts with 'ABC'";

  11:         return "Unknown pattern";

  12:     }

  13: }

Stubs erzeugen und Exploration starten. Ob PEX wohl solche Operationen wie "StartsWith" und "Length" versteht?

Es findet tatsächlich alle erforderlichen Input-Parameter und sogar noch mehr! PEX stell fest, dass unsere Methode beim Übergeben einer NULL-Referenz eine Exception wirft. Und damit nicht genug, PEX kann uns auch einen Vorschlag machen, wie wir unseren Code verbessern können. Dazu im "Pex Exploration Results" - Fenster unter Views "Show suggestions window" aufrufen.

Durch einen Doppelklick auf den Eintrag am unteren Rand des Bereichs öffnet sich ein Fenster, das die vorgeschlagene Änderung direkt in unseren Code einfügen kann.

   1: public string CheckString(string Input)

   2: {

   3:     // <pex>

   4:     if (Input == (string)null)

   5:         throw new ArgumentNullException("Input");

   6:     // </pex>

   7:     if (Input.StartsWith("abc") && Input.Length > 10)

   8:         return Input + " Starts with 'abc' and length > 10"; 

   9:     if (Input.StartsWith("abc"))

  10:         return Input + " Starts with 'abc'";

  11:     if (Input.StartsWith("ABC"))

  12:         return Input + " Starts with 'ABC'";

  13:     return "Unknown pattern";

  14: }

Die Zeilen 3-6 wurden von PEX erzeugt. Natürlich können wir das entsprechende Verhalten im Code direkt ändern und an unsere Vorstellungen anpassen. Vielleicht ist es aber gar keine schlechte Idee, in diesem Fall eine Exception zu werden. Dies ist das Standard-Verhalten von PEX an dieser Stelle. Wird die erwartete Exception nicht mehr geworfen oder eine andere Exception tritt auf, wird dies durch einen fehlgeschlagenen Test angezeigt.

Der nächste bitte!

So nun wollen wir noch einen Schritt weitergehen und sehen, wie PEX mit Listen umgehen kann. Dazu habe ich folgende Testmethode erstellt (über den Sinn einer solchen Methode wollen wir jetzt nicht nachdenken)

   1: int result = 0;

   2: if (list.Count > 10)

   3: {

   4:     foreach (int i in list)

   5:         result += i;

   6: }

   7: else

   8: {

   9:     foreach (int i in list)

  10:         result *= i;

  11: }

  12: return result;

Die Methode bekommt eine Liste von Integer-Werten übergeben. Wenn es mehr als 10 Elemente sind, werden diese addiert, sonst werden die Werte miteinander Multipliziert. Mal sehen, wie PEX mit Listen umgeht.

PEX erkennt noch, dass unsere Methode mit Null-References nicht korrekt umgeht, aber dann verließen sie ihn.  Aber freundlicherweise bekommen wir noch einen Hinweis "2 Object Creations". klickt man darauf, dann bekommt man schon mehr Informationen.

Aha, PEX kann also eine List<int> nicht erzeugen. Also was tun? Klickt man den unteren der beiden Einträge an, bietet PEX etwas weiter rechts die Möglichkeit eine Factory zu definieren. Eine Factory ist ein Extensibility-Point mit dem PEX beigebracht werden kann mit solchen Objekten umzugehen. Ein Beispiel für eine solche Factory kann so aussehen:

   1: namespace System.Collections.Generic

   2: {

   3:     [PexFactoryClass]

   4:     public partial class ListFactory

   5:     {

   6:         [PexFactoryMethod(typeof(List<int>))]

   7:         public static List<int> Create(int i)

   8:         {

   9:             if (i > 100)

  10:                 i = 100;

  11:             List<int> l = new List<int>();

  12:             for (int j = 0; j < i; j++)

  13:             {

  14:                 l.Add(j * 10);

  15:             }

  16:             return l;

  17:         }

  18:     }

  19: }

Hier teilt man PEX nun mit, welche Elemente es damit erzeugen kann (Zeile 6). Anschließend implementiert man eine Create-Methode die beliebige Parameter übernehmen kann. In Abhängigkeit dieser Parameter wird nun eine Instanz des gewünschten Objektes erzeugt. In unserem Beispiel übernehmen wir nur einen Parameter der die Länge der Liste angibt. In den Zeilen 9/10 begrenzen wir die Länge der Lsite auf 100 Elemente. Die Liste selbst befüllen wir mit einer Reihe von Zahlen. Hier ist es sicher keine gute Idee, z.B. Zufallszahlen zu verwenden, da diese ja bei jedem Testdurchlauf andere Werte liefern und deshalb der Assert nicht erfolgreich ausgeführt werden kann.

Mit hilfe dieser Factory kannPEX nun unsere Testcases definieren. Dazu ermittelt es einfach geeignete Parameter für die Create-Methode in unserer Factory statt das Objekt selbst zu erzeugen.

Die erzeugten Tests sehen dann so aus:

   1: [TestMethod]

   2:         [PexGeneratedBy(typeof(ListCalculationTest))]

   3:         public void SumList03()

   4:         {

   5:             List<int> list;

   6:             int i;

   7:             list = ListFactory.Create(2);

   8:             ListCalculation listCalculation = new ListCalculation();

   9:             i = this.SumList(listCalculation, list);

  10:             Assert.AreEqual<int>(0, i);

  11:         }

  12:  

  13:         [TestMethod]

  14:         [PexGeneratedBy(typeof(ListCalculationTest))]

  15:         public void SumList04()

  16:         {

  17:             List<int> list;

  18:             int i;

  19:             list = ListFactory.Create(536870912);

  20:             ListCalculation listCalculation = new ListCalculation();

  21:             i = this.SumList(listCalculation, list);

  22:             Assert.AreEqual<int>(49500, i);

  23:         }

Nun folgt noch die Kür

Nach den Erfahrungen mit der Liste bereits etwas skeptischer geworden, wollen wir's jetzt aber doch wissen. Wie sieht's mit eigenen Objekten aus? Wie weit kommt PEX damit? Auch hier gibt es wieder eine einfache Methode die wir testen wollen:

   1: public class ComplexDataCalculation

   2: {

   3:     public string DoComplexDataCalculation(cData d)

   4:     {

   5:        if (!d.IsValid)

   6:             return "NotValid";

   7:  

   8:         if (d.DataValues.x1 > d.DataValues.x2)

   9:             return "x1 > x2";

  10:         if (d.DataValues.x1 < d.DataValues.x2)

  11:             return "x1 < x2";           

  12:         else

  13:             return "x1 == x2";

  14:  

  15:     }

  16: }

  17:  

  18: public class cData

  19: {

  20:     public cDataValues DataValues { get; set; }

  21:     public string ObsoleteParameter { get; set; }

  22:     public bool IsValid { get; set; }

  23: }

  24:  

  25: public class cDataValues

  26: {

  27:     public int x1 { get; set; }

  28:     public int x2 { get; set; }

  29: }

Die Methode bekommt einen komplexen Datentyp übergeben. Und was macht PEX???

PEX erkennt nicht nur, dass wir zwei Null-Exceptions abfangen sollten, sondern kann auch unser Datenobjekt so initialisieren, dass wir wieder eine 100% Codeabdeckung bekommen. Die Unit-Tests sehen ungefähr so aus:

   1: [TestMethod]

   2: [PexGeneratedBy(typeof(ComplexDataCalculationTest))]

   3: public void DoComplexDataCalculation04()

   4: {

   5:     cDataValues cDataValues;

   6:     cData cData;

   7:     string s;

   8:     cDataValues = new cDataValues();

   9:     cDataValues.x1 = 3;

  10:     cDataValues.x2 = 4;

  11:     cData = new cData();

  12:     cData.DataValues = cDataValues;

  13:     cData.ObsoleteParameter = "";

  14:     cData.IsValid = true;

  15:     ComplexDataCalculation complexDataCalculation = new ComplexDataCalculation();

  16:     s = this.DoComplexDataCalculation(complexDataCalculation, cData);

  17:     Assert.AreEqual<string>("x1 < x2", s);

  18: }

Das ist schon extrem beeindruckend, wie PEX tatsächlich eine entsprechende Instanz unseres Datenobjektes erzeugt und initialisiert und das so, dass wir alle Testcases abdecken. Wirklich beeindruckend.

Was haltet ihr davon? Würde mich über Feedback freuen.

Nächste Woche Dienstag bin ich mit zwei Vorträgen auf der ADC08 vertreten.

Testing Practices mit VSTS und TFS
VSTS bringt eine ganze Reihe von Testmethoden. Insbesondere die Edition für Tester bietet verschiedene Testarten. Die Implementierung der unterschiedlichen Testarten ist inzwischen hinlänglich beschrieben. Wie diese Tests in Real-World-Projekte eingesetzt werden, um tatsächlich die Qualität zu verbessern, beschreibt der Vortrag ebenso wie die Lösung von Real-World-Problemen. Dabei werden Themen wie die Bereitstellung von Testumgebungen, Testplanung und Testdurchführung sowie Testdokumentation ebenso beleuchtet wie die Frage, in welchen Fällen eine Edition für Tester notwendig ist, wo es mögliche Alternativen gibt und wie verschiedene Akteure innerhalb des Projekts wie z.B. Fachabteilungen eingebunden werden.

UI-Testing mit UI Automation
Unit-Testing und Web-Testing verbreiten sich mit VSTS und anderen Testing-Tools immer mehr. Was diese Testmethoden jedoch nicht abdecken, ist quasi die „letzte Meile“, die Oberfläche der Anwendungen. Um diese in Tests einzubinden sind entweder teure Tools erforderlich, oder man nutzt das weitgehend unbekannte UI Automation Framework, das Bestandteil des .NET 3.0 Frameworks ist. Der Vortrag erläutert zunächst, wie man mit Hilfe des UI Automation Frameworks Windows- und Web-Anwendungen kontrollieren kann. Anschließend werden diese Methoden in Unit-Tests integriert, um damit automatisierte UI-Tests aufzubauen. Als krönender Abschluss wird ein UI-Test-Rekorder implementiert, mit dem UI-Aktionen aufgezeichnet und automatisiert in Unit-Test überführt werden können. Der Vortrag beschreibt neben den Möglichkeiten auch Grenzen des UI Automation Frameworks und mögliche Lösungen.

Seit ein paar Tagen ist ein neuer Web-Cast online in dem ich zusammen mit Christian Binder zusammen erörtere welche Vorteile die hierarchische Organisation von Workitems bietet. Ohne schon zuviel vom Inhalt verraten zu wolle, es geht um Requirementmanagement, Traceability, Impace-Analyse und einiges mehr. Im Webcast wird ein kostenloses Tool vorgestellt mit dem bereits mit TFS 2008 hierarchische Workitems realisiert werden können.

Ok, OK, ich weiß, ich bin spät dran, aber ich möchte dennoch nicht versäumen, einen kurzen Rückblick auf den Herbstcampus zu tun und meine Folien zu veröffentlichen.

Interessant war für mich an der Veranstaltung, dass es Tracks sowohl für JAVA als auch .Net gab. Ich selbst hatte zwei Talks:

Qualitätsmanagement mit VSTS und TFS
In dieser Session habe ich zunächst einmal beleuchtet, warum Entwickler QM nicht unbedingt mögen. Einer der Gründe liegt in der mangelnden Integration von QM in den Entwicklungsprozess. Gerade hier bietet VSTS und TFS einige Verbesserungen. Wichtig ist, dass QM nicht erst mit dem Testing beginnt, sondern bereits früh im Prozess ansetzen muss. Ohne ein gutes Requirement-Management wird kein gutes Qualitäts-Management möglich sein. Im Vortrag habe ich demonstriert, welche Methoden mit diesem Toolset über die verschiedenen Prozessphasen zur Verfügung stehen um in Software-Projekten wirklich mehr Qualität zu erzielen.

Agile Development Process - Ein Architektur-basierter Entwicklungsprozess

Architektur und Prozesse werden meist getrennt betrachtet. Dass aber gerade eine gemeinsame Betrachtung dieser beiden Themen viele Vorteile bringt, habe ich versucht in dieser Session zu vermitteln. Im Kern ging es darum, dass verschiedene Prozesse wie z.B. das UI Driven Development erst durch eine passende Architektur ermöglicht wird. Sehr gut fand ich auch die Diskussion am Ende meines Vortrags. Das versprochene Whitepaper zu diesem Vortrag wird noch nachgereicht.

Am 08.10.2008 haben wir Stefan Lieser zu Gast bei der .Net Developer-Group Ulm. Er wird in seinem Vortrag einige "Software Design Principles" vorstellen und erläutern wie diese helfen, Software wartbarer wird.

Mitglieder und Gäste sind herzlich eingeladen. Weitere Infos unter http://www.dotnet-ulm.de/Treffen.aspx

Vom 19.11 bis zum 21.11.2008 findet in Berlin der Technical Summit statt. Neben einem Überblick über die aktuellen Microsoft Entwicklungstechnologien könenn sie sich hier auch über die wichtigsten Trends auf der DC informieren.

Ich bin auf dem Technical Summit als Sprecher und als ATE vertreten sein. Meine Vortragsthemen:

Zusammen mit Christian Binder habe ich nun einen MSDN Webcast aufgenommen der sich mit dem Thema UI Events und Record & Play für UI Testing beschäftigt. Dieser Webcast ist als Fortsetzung zum Thema UI Testing mit dem UI Automation Framework aufgebaut. Der Webcast selbst wird als Download ab dem 08.08.08 (cooles Datum) verfügbar sein. Den Demo_Code zum Webcast kann man ab sofort hier runterladen.

Kurz hier der Inhalt des Webcasts zusammengefasst.

Über das UI Automation Framework kann man Events aus einer Anwendung abfangen. Diese Events kann man zunächst am besten mit dem UISpy untersuchen. Nun kann man einen kleinen Recorder erstellen, der diese Events nutzt, um Benutzereingaben in einer Anwendung zu erkennen und automatisiert Code erstellt, der diese Benutzereingaben simuliert. Dieser Code kann nun in einem Unit-Test genutzt werden um automatisiert im Rahmen eines Testdurchlaufes die Benutzerinteraktion zu wiederholen. Der Clou dabei ist, dass sogar die Asserts für die erwarteten Ergebnisse automatisiert aufgezeichnet werden können.

Download Demo-Code 

Download Webcast

Ich bin gerade dabei, für den Herbst meine Vorträge zu koordinieren. Ich werde von September bis Dezember viel unterwegs sein. Nun habe ich mal die ganzen aktuellen Vortragsthemen gesammelt, um hier einen kleinen Überblick zu geben. Wer Interesse hat, einen dieser Vorträge zu hören, ich werde in Kürze die Termine veröffentlichen, an denen ich die jeweiligen Vorträge halten werde. Möchte mich jemand für einen Vortrag buchen, einfach eine kurze Mail an mich. Für INETA User-Groups besteht auch die Möglichkeit, mich über das deutsche Speaker-Bureau zu buchen. Sollte sonst jemand Interesse an einem Vortrag zu den Themengebieten VSTS und Team Foundation Server, Software-Architektur, Entwicklungsprozesse oder Qualitätsmanagement haben, ich bin gerne bereit, mein Angebot entsprechend zu erweitern.

Am morgigen Dienstag findet um 18:00 das nächste Treffen der .net Developer-Group Ulm statt. Thema ist dann die Windows Presentation Foundation. Als Sprecher konnten wir Gerhard Jaros von der EPS Software GmbH gwinnen, der uns fundierte Einblicke in diese immer noch recht neue Technologie geben wird. Der Abstract zum Vortrag lautet:

Windows Presentation Foundation ... nach 20 Jahren hat Microsoft uns Entwicklern nun eine neue Alternative gegeben, mit Hilfe derer wir flexible User Interfaces erstellen können. Wir sind plötzlich nicht mehr gezwungen, einen Standard zu verwenden, der sich im Laufe der Zeit entwickelt hat. Buttons können bunt sein, Masken rund, transparent und farbenfroh. Wie aber geht das, wozu brauchen wir es und was bringt es uns?
Wir brauchen es. Dringender denn je. Wir wollen Interfaces schaffen, die keine weitere Erklärung mehr benötigen, weil der Anwender sie aufgrund des logischen Aufbaues selbst versteht. Diese Themen werden im Workshop behandelt:

• Aufbau von WPF
• Einfache WPF-Codebeispiele
• Tipps & Tricks / best practices
• Wann soll man WPF verwenden und wann nicht?

Noch dazu hat man bei dieser Gelegenheit auch Silverlight entwickelt, und so kann man erstmals mit ein und derselben Sprache sowohl für Windows-Applikation als auch für Web- Anwendungen Frontends erstellen. Es wird also in diesem Zusammenhang auch auf Silverlight verwiesen.

Weitere Informationen unter www.dotnet-ulm.de

Heute hatten wir bei der UG Ulm Christian Binder als Sprecher zu Gast. Christian gewährte uns einen kleinen Blick in die Zukunft der Software-Entwicklung. Er stellte einige der neuen Funktionen aus den Bereichen Project Management, Testing, Development und Architecture. Obwohl für die Demo nur das aktuelle CTP zur Verfügung stand, wurde ersichtlich, dass mit Rosario viele neue Funktionen kommen, auf die Entwickler, Tester, Architekten und Projektleiter schon lange gewartet haben. Einige der Highlights waren:

• Lightweight Projektmanagement und Kapazitätsplanung
• Neue Verknüpfungen und hierarchische Workitems
• Build definition über Workflow Foundation
• Planung und Verwaltung von manuellen Tests
• Aufzeichnung eines Web UI-Tests und Umwandlung in einen coded Test
• Historical Debugging
• Sequential Diagramms
• und vieles mehr

Danke an Chris für den tollen Vortrag.

Am 28.05.2008 findet um 18:00 Uhr das nächste Treffen der .net DeveloperGroup Ulm statt. Diesesmal haben wir Christian Binder, Microsoft Evangelist zu Gast, der uns einen Blick in die Zukunft gewährt. Er wird in seinem Vortrag Neuerungen von Rosario, dem Nachfolger von Visual Studio 2008 vorstellen. Rosario bring viele neue Funktionen, die für alle Entwickler interessant sein dürften. Wer also wissen will, was auf uns zukommt, der sollte sich diese Veranstaltung nicht entgehen lassen.

Nähere Informationen gibt es unter http://www.dotnet-ulm.de/Treffen.aspx

Die Videos zu den Sessions vom Launch-Event in Frankfurt im Februar sind jetzt für alle frei verfügbar.

Ich hatte ja die Möglichkeit, am Ende einer Session von Christian Binder kurz vorzustellen, wie wir den TFS in unserem Entwicklungsprozess nutzen.

Das Video kann man hier abrufen. Mein Einsatz beginnt dann ab der Minute 54. Mein Video, das ich in dem Vortrag nutze, kann hier heruntergeladen werden.
War echt ne coole Sache vor mehr als 500 Leuten zu reden.

Visual Studio 2008 Team System 2008 - {Überblick}

Ich war in den letzten Tagen auf der TeamConf 2008 in München. Es war sehr schön zu sehen, dass Team System inzwischen recht gut etabliert. Es gab auf dieser Konferenz eine ganze Reihe von Praxisberichten die darstellten, welche Erfahrungen Anwender bereits mit Team System gesammelt haben. Und es war sehr interessant, mit vielen Leuten aus dem ALM-Umfeld zu diskutieren. Ein persönliches Highlight war für mich, ein Treffen mit Sam Guckenheimer, Group Product Planner bei Microsoft, der sich unseren WorkitemManager angesehen hat und mit dem ich einige Ideen diskutieren konnte.

Ich habe auf der TeamConf einen Vortrag zu Programmierung mit dem TFS API am Beispiel einer hierarchsichen Workitem-Organisation gehalten.

Der AfterLaunch Event in Köln war eine sehr gute Veranstaltung und sehr professionell organisiert. Für die lächerliche Teilnahmegebühr von nur 8,-- € haben die Teilnehmer hochkarätige Vorträge rund um die 2008er Launch-Produkte von Microsoft erhalten. Großer Wert wurde dabei auf den Praxisbezug der Vorträge gelegt. Auch ich war dabei und hatte zwei Sessions zum Einsatz des Team Foundation Servers 2008 in der Praxis. Leider hatte ich etwas mit dem Beamer zu kämpfen, ich hoffe aber dass die Teilnehmer dennoch einige Tipps zum Einsatz des TFS mitnehmen konnte und ich den einen oder anderen animieren konnte dieses Tool nun doch einmal zu installieren und sich näher damit zu beschäftigen.

Am Donnerstag, 10.04 war ich zu Gast bei der Usergroup Braunschweig und habe dort den Vortrag zum Thema Qualitätsmanagement mit Visual Studio Team System 2008 und Team Foundation Server gehalten. Der Vortrag war für mich sehr interessant, da es eine rege Beteiligung und viele Fragen durch die Teilnehmer gab.

Vielen Dank an Lars für die Einladung.

Folien zum Vortrag

Beispielcode zum Vortrag