Am 1. Oktober fand die Visual Studio 2012 Evolution in Neuss statt. Die verschiedenen Vorträge wurden aufgezeichnet und die Videos stehen nun zur Vefügung unter http://www.microsoft.com/germany/msdn/events/vs-evolution-2012/default.aspx

Vom 27. bis 30. November finden die ALM Days in München statt, für alle TFS Anwender eigentlich eine Pflichtveranstaltung, da hier versammelt ist, wass im Visual Studio ALM Umfeld Rang und Namen hat. Allein die beiden Key-Note Speaker Brain Harry und Sam Guckenheimer sind Grund genug, diese Veranstaltung nicht zu versäumen.

Im Rahmen der ALM Days werden mein Kollege Thomas Trotzki und ich mit diversen Vorträgen und Workshops vertreten sein. artiso wird auf den ALM Days auch als Austeller vertreten sein. Ich würde mich freuen, den einen oder anderen Leser meines Blogs auf den ALM Days zu treffen. Jeder der mich dort anspricht und sich als Leser meines Blogs “outet” bekommt von mir einen Satz Planning-Poker Karten :-)

Hier schon mal ein Ausblick auf unsere Ganztages-Workshops:

ALM & TFS für C++ Programmierer

Referent:Thomas Trotzki, artiso AG

Datum und Uhrzeit: 30. November 2012, 9:00 - 17:00 Uhr

Anspruch: TFS-Einsteiger

Abstract:  Im C++ Umfeld werden bislang bis auf Version Control nur vereinzelt weitere Bausteine des ALM verwendet, obwohl es hierfür aus technischer Sicht keine Gründe gibt. Dieser Workshop richtet sich daher an alle C++ Entwickler, die momentan noch auf die Vorzüge der Integration der unterschiedlichen ALM Aspekte in Team Foundation Server verzichten. Anhand eines überschaubaren Beispiels wird die Arbeit mit Visual Studio 2012 und Team Foundation Server 2012 von der Planung über die Implementierung und die Integration von automatisierten Tests in den zentralen Build Prozess bis hin zum Management von Bugs veranschaulicht. Freuen Sie sich auf einen Tag voller Anregungen und Goodies, und das immer aus der Sicht des Entwicklers.

Es gilt: Hands-On, bringen Sie ruhig Ihr Laptop mit!

TFS 2012 für Scrum-Teams

Referent:Thomas Schissler (MVP für Visual Studio ALM), artiso AG

Datum und Uhrzeit: 27. November 2012, 9:00 - 17:00 Uhr

Anspruch: Grundkenntnisse über Scrum sollten vorhanden sein

Abstract: Der TFS 2012 bringt viele lang vermisste Features für agile Teams und noch einiges mehr. Backlog Management, Task Board, Team-Strukturen, Code Reviews und Feedback Tool sind nur ein Auszug aus den Neuerungen, mit denen der neue TFS aufwarten kann.

In diesem Workshop werden die Teilnehmer am eigenen PC einen kompletten Scrum-Zyklus durchspielen und dabei diese Features nicht nur kennen lernen, sondern es wird auch ausreichend Zeit sein, um über Einsatzszenarien, Alternativen und mögliche Defizite zu diskutieren.

Hilfreich ist, wenn die Teilnehmer bereits mit den Grundkonzepten von Scrum vertraut sind, da auf diese im Workshop nicht gezielt eingegangen wird.

Test-Strategien für agile Teams

Referent: Thomas Schissler (MVP für Visual Studio ALM), artiso AG

Datum und Uhrzeit: 30. November 2012, 9:00 - 17:00 Uhr

Anspruch: Einsteiger

Abstract: Klassische Test-Strategien sind darauf ausgelegt, dass zwischen Entwicklung und Auslieferung eine intensive Test-Phase erfolgt. Für agile Teams, die auf sehr kurze Auslieferungsintervalle setzen, sind diese Strategien unbrauchbar.

Der Workshop zeigt auf, wie sich eine effiziente Test-Strategie für agile Software-Projekte von klassischen Ansätzen unterscheidet, welche neue Methoden und Techniken agile Teams idealerweise benutzen und welche Rolle dabei der Test-Automatisierung zukommt.

Darüber hinaus werden aber auch sog. weiche Faktoren wie Team-Organisation und Mindset betrachtet.

Und natürlich gibt es jede Menge Hands On, um die vorgestellten Tools wie Unit-Testing, UI-Testing, Microsoft Test Manager, Performance- und Load Tests, Test Reporting etc. auch gleich kennen zu lernen und praktisch anwendbares Wissen mitzunehmen.

Nachdem ich beim deutschen Launch Event zu Visual Studio 2012 und .Net 4.5 mit dabei sein darf, hier ein paar Informationen zu dieser Veranstaltung von Christian Binders Blog:

Visual Studio 2012 und das .NET Framework 4.5 ist fertig und wir laden Euch am 1. Oktober in Düsseldorf zu unserem offiziellen Launch Event ein. Es gibt eine Menge Neuerungen, die wir Euch zeigen wollen und natürlich haben wir Top Sprecher aus der .NET Community mit dabei. Die Keynote wird Brandon Bray zum Thema “ .NET from Past to Future” halten. Brandon ist Director .NET Core Platform und arbeitet am Campus in Redmond. Ich freue mich Brandon für dieses Event gewonnen zu haben, denn Ihr wollt Doch aus erster Hand erfahren, wo die Reise hingeht. Auch möchten wir, dass der Launch die Möglichkeit zum Austausch und Networking in der .NET Community bietet. Das Event wird kostenfrei sein und ihr könnt Euch ab dem 14.8 auf der Visual Studio Webseite anmelden. Hier schon mal ein Blick auf die Inhalte:

 

Würde mich freuen den einen oder anderen Leser meines Blogs dort zu treffen

Das Thema C++ scheint tatsächlich doch (wieder) auch bei Microsoft eine große Aufmerksamkeit zu erhalten. Jedenfalls bietet mein Kollege Thomas Trotzki nun eine zweite Runde der erfolgreichen Roadshow C++ Day mit neuen Inhalten und Themen in Zusammenarbeit mit Microsoft an. Also, wer mit C++ entwickelt sollte sich diese kostenlkose Info-Veranstaltung nicht engehen lassen.

Nach einem sehr erfolgreichen ersten C++Day dieses Jahr und einer sehr gut besuchten ADC C++ möchten wir weiter kontinuierlich Themen für C++ Entwickler anbieten. Daher laden wir zu einem weiteren kostenfreien C++ Day 2012 mit dem folgenden Schwerpunkten ein:

“Windows 8 für C++ Entwickler”, um die neuen sehr guten Möglichkeiten für C++ Entwickler mit Windows 8 zu beleuchten. “ALM für C++ Entwickler”, für alle C++ Entwickler, die Ihre Entwicklungs Infrastruktur optimieren möchten.

Teilnahme: Kostenlos

Wann? Wo?

14.06.2012 14:00 - 19:00 Berlin: DETAILS u. ANMELDUNG
18.06.2012 14:00 - 19:00 München: DETAILS u. ANMELDUNG
25.06.2012 14:00 - 19:00 Köln: DETAILS u. ANMELDUNG
26.06.2012 14:00 - 19:00 Bad Homburg: DETAILS u. ANMELDUNG
03.07.2012 14:00 - 19:00 Ulm/Blaustein: DETAILS u. ANMELDUNG

Folgende Themen erwarten Sie:

14:00 - 15:15 | Windows 8 Metro Style Apps mit C++ und XAML

Unter Windows 8 erhält nun auch der C++ Programmierer die Möglichkeit optisch modernste Benutzerschnittstellen mit XAML zu „deklarieren“ und auf die Windows Runtime (WinRT) zurückzugreifen. Somit steht für Windows 8 Metro Style Apps erstmals ein neues UI Framework zur Verfügung. Dieser Vortrag vermittelt Ihnen die wesentlichen Grundlagen zu Windows 8 Metro Style Apps mit dem dazugehörigen Interaktionsmodell und zeigt, wie Sie mit Visual C++ und XAML eigene Metro Apps erstellen können. Das Konzept des App Stores rundet den Vortrag ab.

15:15 – 15:30 Pause

15:30 - 16:45 | WinRT für C++ Entwickler

Die Windows Runtime (WinRT) ist die neue Library für Metro Style Apps. Mit native C++ lassen sich Komponenten und Treiber für WinRT und damit für Metro Style Apps erstellen. Hierfür hat Microsoft die C++ Syntax wie bereits für C++ /CLI erweitert, es steht nun C++ /CX zur Verfügung. Erfahren Sie in diesem Vortrag, wie Sie mit Visual C++ WinRT Komponenten erstellen und in Metro Apps verwenden können. Ein besonderer Fokus wird dabei auch auf die C++ /CX Spracherweiterungen gesetzt. Eine Abgrenzung von C++ /CX zu C++ /CLI und C# rundet diesen Vortrag ab.

16:45 – 17:15 Pause

17:15 - 18:30 | ALM in C++ Projekten

Im C++ Umfeld werden bislang häufig bis auf Version Control nur vereinzelt weitere Bausteine des ALM verwendet, obwohl es hierfür aus technischer Sicht keine Gründe gibt. Dieser Vortrag richtet sich daher an alle Entwickler, die bislang auf die Vorzüge der Integration der unterschiedlichen ALM Aspekte in Team Foundation Server verzichtet haben. Anhand eines überschaubaren Beispiels wird die Arbeit mit Visual Studio 11 und Team Foundation Server 11 von der Definition eines Requirements, über die Implementierung und die Integration von automatisierten Tests in den zentralen Build Prozess bis hin zum Management von Bugs veranschaulicht. Abschließend gibt der Vortag einen kompakten Ausblick auf die für C++ Entwickler relevanten Neuerungen mit TFS 11.

18:30 - 19:00 Q&A

Zusammen mit meinen MVP-Kollegen Sven Hubert und Neno Loje sowie Christian Binder, Daniel Meixner, Patric Boscolo und Uwe Baumann von der Microsoft bin ich am 24.04, 25.04, 26.04 und 10.05 in Deutschland unterwegs um die nächste Version von Visual Studio und TFS vorzustellen.

Agenda

Weitere Informationen und die Anmeldung finden sich hier: http://www.microsoft.com/germany/visualstudio/events/eleven-roadshow.aspx

Visual Studio 11 Beta Roadshow Trailer from MSDN Coding Class (Microsoft) on Vimeo.

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:

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.

Titel	Dauer	Abstract
Qualitätsmanagement mit VSTS und TFS	1 Std - 3 Std.	Qualität spielt bei Software eine immer stärkere Rolle. Gleichzeitig werden immer effizientere  Entwicklungsprozesse angestrebt. Dies lässt sich nur mit geeigneter Tool-Unterstützung und passenden Lösungen zu Prozessen und Software-Architektur erzielen. Mit Visual Studio Team System und Team Foundation Server stehen Tools zur Verfügung, die nicht nur eine entsprechende Testunterstützung bietet, sondern auch komplette Qualitätsprozesse unterstützt. Der Vortrag zeigt, wie Qualitätsprozesse durch TFS unterstützt werden. Anschließend werden verschiedene Testmethoden vorgestellt und einige Praxis-Tipp für deren Einsatz gegeben.
Agile Development Process - Ein Architekturbasierter Entwicklungsprozess	1 Std Vortrag, 1 Std. Demo	Moderne Software-Anwendungen werden immer komplexer. Dadurch gewinnt auch die Software-Architektur immer mehr an Bedeutung. Wartbarkeit, Testbarkeit, Erweiterbarkeit und Teamentwicklung sind nur einige Aspekte, die eine gute Architektur unterstützen soll. Doch diese Aspekte können nicht durch ein einzelnes Architekturkonzept abgedeckt werden. Dieser Vortrag stellt verschiedene Architektur-Patterns wie Komponentenorientierung, Contract First Design, Service-Orientierung und UI Driven Development vor. Und vor allem wird gezeigt, wie diese Konzepte zu einem praxiserprobten Entwicklungsprozess verbunden werden können.
Mehrschichtige Architekturen mit .Net	1 Std.	Mehrschichtige Architekturen sind heute eigentlich oft Standard, vor allem bei verteilten Anwendungen. Allerdings wird diese Architektur oftmals zu sehr an technischen Belangen ausgerichtet. Die Session zeigt, wie man mehrschichtige Architekturen plant und diese flexibel und leitungsfähig aufbaut. Es werden verschiedene praxiserprobte Patterns vorgestellt.
Build-Management mit Team Foundation Server	1 Std.	Mit Team Foundation Server steht ein leistungsfähiges integriertes Buildsystem zur Verfügung. Wie man dieses im Rahmen der Projekte nutzt und welche Vorteile sich daraus ergeen zeigt diese Session. Darüber hinaus wird der Einsatz verschiedener Buildsteps zum Deployment, Versionierung etc. vorgestellt.
Testing Practices mit VSTS und TFS	1 Std. - 3 Std.	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	1 Std. - 1,5 Std.	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 WPF-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-Recorder 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.
Closing Tool-Gaps in your Development Process with the TFS API	1 Std.	The efficiency of development processes is based on a powerful and integrated tool support. But development processes are individual and no standard software can fulfill this integration 100%. With the Team Foundation Server API we have a powerful technology to extend the standard functionality for our needs. As an example in this session we will live code a tool to organize workitems in a hierarchical way and you will learn how this can improve your development process. Also you will get some additional visions about how you can use TFS Extensibility to make real cool things with your TFS.
Lücken in der Tool-Unterstützung für IhrenEntwicklungsprozess mit der TFS API schließen	1 Std.	Die Effizienz eines Entwicklungsprozesses hängt stark von einer leistungsfähigen und integrierten Entwicklungsplattform ab. Aber Entwicklungsprozesse sind individuell an keien Standardsoftware kann eine 100%ige Integration gewährleisten. Mit der Team Foundation Server API steht eine leistungsfähige Technologie zur Verfügung, die es erlaubt, die Standard-Funktionen des Team Foundation Servers bedarfsgerecht zu erweitern. Als Beispiel wird in dieser Session ein live ein Tool erstellt, das eine hierarchische Organisation von Workitems ermöglicht. Und es wird erläutert, wie damit Entwicklungsprozesse verbessert werden können. Darüber hinaus werden verschiedene Visionen aufgezeigt wie man mit Hilfe der TFS Extensibility richtig coole Sachen für den TFS machen kann.
Durchgängige Entwicklungsprozesse mit Visual Studio Team System	1 Std.	Mit Visual Studio Team System bietet Microsoft eine leistungsfähige Entwicklungsplattform die den gesamten Lebenszyklus eines Entwicklungsprojektes vom Requirement Management bis zum Systembetrieb abbilden kann. Der Vorteil dabei ist, dass alle wichtigen Elemente des Prozesses in einem System integriert und so Verbindungen zwischen den einzelnen Prozessartefakten hergestellt werden können. Der Vortrag zeigt wie ein kompletter Entwicklungsprozess mit VSTS abgebildet werden kann. Als Beispiel wurde hierzu bewusst ein agiler Prozess gewählt der vor allem auch für kleinere Entwicklungsteams geeignet ist. Dabei werden die wesentlichen Funktionselemente von Visual Studio Team System und Team Foundation vorgestellt und deren Nutzung im Prozess gezeigt.
Reporting mit dem TFS	1 Std.	Der Team Foundation Server bietet umfangreiche Projekt-Kennzahlen. Neben Prozess- und Qualitätskennzahlen sowie verschiendenen Planungskenngrößen können auch weitere Daten wie z.B. zum Build-Prozess oder aus der Quellcode-Verwaltung ausgewertet werden. Hierbei stehen mit den SQL Server Reporting Services und Excel zwei leistungsfähige Tool zur Verfügung, diese Daten zu visualisieren. Der Vortrag zeigt anhand verschiedenen Beispielen auf, wie individuelle Auswertungen erstellt werden können und welche Möglichkeiten sich damit eröffnen.
UI Driven Development - Von der UI zur Anwendung	0,5 Std. - 1 Std.	Missverständnisse und unterschiedliche Interpretation von Spezifikationen sind in Software-Projekten heute an der Tagesordnung. Was also tun, um dieses zu vermeiden? Die Spezifikation noch detaillierter formulieren? Einen anderen Ansatz geht UI Driven Development. Hierbei wird die Oberfläche einer Anwendung als Spezifikationsbestandteil aufgefasst. Der Clou dabei ist, das bei diesem Vorgehensmodell nicht irgendwelche Prototypen entstehen, die die spätere Funktionalität und Aufbau nur vage wiedergeben, sondern "erlebbare" Oberflächen. Und diese Oberflächen können in das Finale Projekt 1:1 übernommen werden, so dass der Investierte Aufwand direkt dem Projekt zugute kommt. Der Vortrag erläutert Architekturkonzepte und Vorgehensmodelle die UI Driven development ermöglichen.
Organisation von Entwickler-Teams	0,5 Std. - 1,5 Std.	Dieser Vortrag ist als Interactive Session konzipiert. Die Teilnehmer können in einer moderierten Diskussionsrunde sich austauschen über verschiedene Erfahrungen mit unterschiedlichen Modellen der Team-Organisation. Der Moderator stellt dabei im Laufe der Veranstaltung verschiedene Aspekte der Team-Organisation und mögliche Vorgehensweisen vor und stellt diese zur Diskussion. Dabei werden Themen wie Generalisten vs Spezialisten, Kommunikation im Team, Mitarbeitermotivation und vieles mehr ausführlich diskutiert.
Automatisierte Generierung von Unit-Tests mit PEX	0,5 Std.	PEX - ein Tool von Microsoft Research verspricht nichts weniger als die automatisierte Generierung von Unit-Tests und zwar mit dem Ziel einer möglichst vollständigen Code-Abdeckung. Wie PEX funktioniert und inwieweit dieses Versprechen eingehalten werden kann, zeigt dieser Vortrag. Darüber hinaus wird auch beleuchtet, in welchen Szenarien PEX eine wirklich sinnvolle Unterstützung bei Real-Projekten sein kann und wie man es einsetzen kann.
10 Gründe warum Software-Projekte fehlschlagen können – und was hilft ALM?	1 Std.	Für Probleme in Software-Projekten gibt es vielfältige Gründe. Viele dieser Gründe können jedoch auf suboptimale oder gar nicht vorhandene Prozesse zurückgeführt werden. Der Vortrag analysiert die häufigsten Ursachen für fehlgeschlagene Projekte und zeigt mögliche Lösungen auf. Dabei wird auch beleuchtet wie Application Lifecycle Management organisiert sein muss um hier zu unterstützen.
TDD Quick Start	0,5 Std.	Test Driven Development - Eines der häufigsten Buzz-Wörter wenn es um das Thema Software-Testing geht. Umso erstaunlicher, dass es in der Praxis aber relativ selten zum Einsatz kommt. Häufig liegt es auch daran, dass TDD an gewisse Vorbedingungen in Bezug auf Architektur, Prozesse etc. gebunden ist. Der Vortrag versucht einen Schnelleinstieg in TDD zu geben, wobei versucht wird diese Vorbedingungen weitgehend auszublenden um dem Zuhörer einen möglichst schnellen und unkomplizierten Einstieg zu bieten. Die hierzu erforderlichen Kompromisse werden jedoch am Ende des Vortrages aufgezeigt und ein Ausblick auf optimierte Lösungen gegeben.

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:

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:

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.

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:

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