application ifecycle anagement mit visual studio v...

Application Lifecycle Management mit Visual Studio vNext

Höhere Produktivität und bessere Vorhersagbarkeit in der

Softwareentwicklung für Teams jeder Größe

Auf der TechEd North America im Mai 2011 gab Visual Studio-Entwicklungschef Jason

Zander einen kurzen Einblick in die Zukunft der Visual Studio Application Lifecycle-

Managementtools. Dieses Whitepaper fasst diese Informationen und weitere

Neuerungen zusammen. Es umreißt aktuelle Probleme, mit denen sich die

Softwareentwicklungsbranche konfrontiert sieht, und illustriert, wie wir gemeinsam

diese Probleme angehen können, um die Effektivität des Application Lifecycle

Management-Prozesses (ALM) zu verbessern.

© 2011 Microsoft Corporation. Alle Rechte vorbehalten. Dieses Dokument wird Ihnen nur zu Informationszwecken und

ausschließlich „wie besehen“ zur Verfügung gestellt. Die in diesem Dokument enthaltenen Angaben und Daten, einschließlich

URLs und anderer Verweise auf Websites im Internet, können ohne vorherige Ankündigung geändert werden. Alle Risiken durch

die Nutzung des Dokumentes liegen bei Ihnen. Irrtum und Änderungen vorbehalten.

Dieses Dokument gewährt ihnen keine Rechte an geistigem Eigentum aus jeglichen Produkten von Microsoft. Sie dürfen das

Dokument kopieren und für interne Zwecke nutzen.

Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 2 von 28

Inhaltsverzeichnis Application Lifecycle Management mit Visual Studio vNext ..................................................... 1

Die Erwartungen aller Beteiligten sind stetig im Wandel ........................................................... 3

Stakeholdern und Operations .......................................................................................................... 4

Microsofts Prioritäten im Application Lifecycle Management .............................................. 4

Modernes Application Lifecycle Management ............................................................................... 6

Der Anwendungslebenszyklus ......................................................................................................... 6

Anpassung an Marktbedingungen ................................................................................................. 7

Weniger Ressourcenvergeudung .................................................................................................... 8

Best Practices aus der agilen Entwicklung ................................................................................... 8

Application Lifecycle Management mit Visual Studio ............................................................... 10

Die Basis – Visual Studio 2005 und 2008.................................................................................... 10

Reduzierung der Ressourcenvergeudung in der Softwareerstellung – VS2010 ........... 11

Visual Studio vNext: Ausweitung auf den ganzen Entwicklungszyklus und

Einbeziehung neuer Gruppen ............................................................................................................ 12

Agile Planungstools ........................................................................................................................... 13

Einfache Anforderungen .................................................................................................................. 16

Promptes Feedback ........................................................................................................................... 18

Agile Qualitätssicherung .................................................................................................................. 20

Ausrichtung von Entwicklung und Betrieb ................................................................................ 22

Verbesserte User Experience ........................................................................................................... 25

Fazit ............................................................................................................................................................. 28

Jetzt schon im Kalender vormerken:

Die Konferenz zu agiler Entwicklung, Application Lifecycle Management und Test/Qualitätssicherung

mit Visual Studio und Team Foundation Server. 23. bis 25. November in München: www.almdays.de.

http://www.almdays.de/


Die Erwartungen aller Beteiligten sind stetig im Wandel Einer unserer Leitsprüche bei der Veröffentlichung von Visual Studio 2010 lautete „Life

Runs on Code“. Wir wollten so verdeutlichen, wie viele der Aktivitäten des modernen

Lebens von Software beeinflusst werden. Es gab noch nie so viele Möglichkeiten für

die Entwicklung neuer Tools, zur Nutzung von Daten und um Ideen in Software zum

Leben zu erwecken, wie heute.

Die Softwarebranche selbst bleibt jedoch hinter ihren Möglichkeiten zurück. Die

meisten IT-Ausgaben werden nicht dafür aufgewandt, neue Mehrwerte für die

Benutzer zu schaffen, sondern um bestehende Lösungen zu warten, Risiken zu

handhaben und mit den entsprechenden Kommunikationsengpässen umzugehen.

Ressourcen werden so ineffizient eingesetzt. Im Gegenzug werden die Möglichkeiten,

sich auf Kundenanforderungen auszurichten, kaum genutzt.

Im Laufe der Jahre hat die Softwarebranche an der Verbesserung der Effektivität und

Vorhersagbarkeit der Softwareentwicklung gearbeitet. Zwar hat sich die Effektivität in

vielen Bereichen der Softwareerstellung, des Supports und der Wartung erheblich

verbessert, ein großer Teil dieser Fortschritte wurde jedoch nur in ganz speziellen und

eng umrissenen Bereichen erzielt. Die größten Probleme bestehen weiterhin im

Bereich der Übergaben und der Übergänge zwischen den einzelnen Silos im

Anwendungslebenszyklus. Eben diese kommunikativen Effizienzprobleme wurden

bisher nicht ausreichend angegangen.

Die steigenden Erwartungen aller Beteiligten an eine Softwarelösung komplizieren

diese Situation noch. Mit dem Einzug der Cloud wird erwartet, dass Updates der

Produktivsysteme binnen Minuten passieren – nicht erst in Tagen oder gar Wochen.

Auch für Unternehmenssysteme wird eine Benutzerumgebung erwartet, wie sie

beispielsweise bei Mobiltelefonen bekannt ist. Wir befinden uns in einer Situation, in

der die Anforderungen an das gesamte Entwicklungsteam wachsen. Dies macht eine

stärkere Zusammenarbeit und Verknüpfung als bisher erforderlich.


Visual Studio vNext, Stakeholder und Operations „Visual Studio vNext“ ist die von Microsoft verwendete Bezeichnung der

Nachfolgeversion von Visual Studio 2010. Mit Visual Studio vNext bezieht Microsoft

neben den bereits mit Visual Studio 2010 und früheren Versionen nahtlos integrierten

Gruppen der Entwickler, Architekten, Designer, Tester, Requirements Engineers und

Projektmanager speziell die beiden neuen Gruppen der so genannten „Stakeholder“

und „Operations“ eng in den Entwicklungsprozess mit ein.

„Stakeholder“ bezeichnet im weitesten Sinne alle an der Entwicklung beteiligten

Personen, bezieht sich in diesem Kontext allerdings spezifisch auf die Fachseite

und/oder den Kunden und Anwender, die traditionell oft weitgehend vom

Entwicklungsprozess ausgeschlossen waren.

„Operations“ vereinigt in diesem Kontext diejenigen Personen, die für das

Deployment, also das Ausrollen und den Betrieb der Anwendungen verantwortlich

sind, sowie die Wartung, das Einspielen von Updates und die Integration in die

Infrastruktur. Sie werden besser als je zuvor in den Applicationszyklus einbezogen, was

eine deutlich bessere Leistung der individuellen Anwendungen bei gleichzeitig

niedrigerem Aufwand ermöglicht.

Microsofts Prioritäten im Application Lifecycle Management Microsoft hat in den letzten fünf Jahren intensiv daran gearbeitet, Teams so effektiv

wie möglich zu machen und die entsprechenden Probleme anzugehen. Wir haben ein

Application Lifecycle Management-Angebot mit den folgenden Prioritäten entwickelt:

Bessere Zusammenarbeit durch nahtlose Integration aller Rollen im Team

Promptes und direkt umsetzbares Feedback verringert

Ressourcenvergeudung

Verständnis für die individuelle Arbeitsweise und ein Abholen der Benutzer

dort, wo sie sich befinden, und nahtlose Integration ihrer gewohnten

Arbeitsmethoden und Werkzeuge in den Prozess

Transparente und agile Best-Practices, die nach Belieben adaptiert werden

können

Im Rahmen der TechEd North America haben wir einige Szenarien mit Visual Studio

vNext und entsprechenden Integrationskomponenten gezeigt.

Diese Szenarien verbessern die Erstellung, die Wartung und den Support von

Softwarelösungen durch die Verbesserung der Workflows im gesamten Team und

über den gesamten Lebenszyklus hinweg.


In diesem Whitepaper erhalten Sie Hintergrundinformationen und Details zu

verschiedenen Szenarien, wie Visual Studio vNext Softwareentwicklung allgemein und

speziell Application Lifecycle Management für Teams jeder Größe weiter verbessern

wird.

Aktuelle Infos zu Visual Studio vNext online und vor Ort

Jederzeit aktuelle Informationen zur Nachfolgeversion von Visual Studio 2010 erhalten

Sie online in unserem Newsblog unter

http://blogs.msdn.com/b/vsnewsde/archive/tags/vNext

Auf den Visual Studio ALM Days 2011 können Sie die nächste Generation von Visual

Studio erleben: Vom 23. bis 25. November finden in München die Microsoft Visual

Studio ALM Days 2011 (ehemals TeamConf) statt. Dort stellt Microsoft Profis aus der

Softwareentwicklung, IT-Leitern, Softwareprojektmanagern und Softwaretestern die

nächste Generation seiner Entwicklungswerkzeuge für Windows, Web, Phone und die

Cloud vor und präsentiert spannende Neuerungen im Application Lifecycle

Management. Alle Informationen dazu finden Sie unter www.almdays.de

Neben spannenden Sessions erwarten Sie Keynotes von Microsoft-Sprechern aus

Redmond wie Sam Guckenheimer, Product Planner für Visual Studio, und Brian

Harry, Microsoft Technical Fellow und „Vater“ von Visual SourceSafe und Team

Foundation Server. Hinzu kommen lokale Experten wie Christian Binder, ALM

Architect bei Microsoft Deutschland.

http://blogs.msdn.com/b/vsnewsde/archive/tags/vNext

http://www.almdays.de/


Modernes Application Lifecycle Management Traditionelle ALM-Ansätze gehen von der Annahme aus, dass

Softwareentwicklungsprojekte geradlinige und sequenzielle Prozesse seien. Sie setzen

voraus, dass die Anforderungen leicht zu überblicken sind und vorab entsprechend

klar definiert werden können, und dass in der Folge die entsprechenden

Projektphasen der so definierten statischen Grundlinie folgen werden.

In der Realität ist dies jedoch fast nie der Fall. Wirklich alle Anforderungen eines

Softwareentwicklungsprojektes vorab zu überblicken, ist extrem schwierig oder sogar

unmöglich. Unglücklicherweise erkennen viele ältere ALM-Ansätze diese Tatsache

nicht an, zwingen den Teams starre Prozesse auf und schränken sie durch ineffektive

Collaboration-Tools eher ein, als sie zu unterstützen.

Der Anwendungslebenszyklus Software sollte als dynamischer Prozess betrachtet werden. Der

Anwendungslebenszyklus erstreckt sich über alle miteinander in Verbindung

stehenden Aktivitäten während der gesamten Lebensdauer der Anwendung:

Identifikation der geschäftlichen Anforderungen, Entwicklung, Test, Release-

Management und -Überwachung, Support und Wartung bis hin zur

Außerbetriebsstellung der Lösung in weiter Zukunft.

Zwei Workflows mit Beteiligung von verschiedenen Teams, Rollen und Einzelpersonen

sind für den gesamten Lebenszyklus von besonders entscheidender Bedeutung:

1. Schnellere Einsatzbereitschaft: Vom Konzept zu den Produktivsystemen

2. Kürze Problem-Fix-Zyklen: Von der Erkennung von Problemen zu deren

Behebung

Ein modernes ALM-Toolset muss diese beiden Workflows unterstützen und den

Übergang zwischen dem Entwicklungsteam und dem Betriebsteam beschleunigen.

Abbildung 1: Etablierung von Workflows zwischen Entwicklung und Betrieb – Anwendungen entwickeln sich

bei neuen Anforderungen weiter. Es besteht eine enge Verbindung zwischen dem Entwicklungs- und dem

Betriebsteam. An den Übergabepunkten zwischen den Teams entstehen traditionell Engpässe und

Kommunikationsprobleme.


Damit ein Projekt in der geplanten Spur bleibt, reichen verknüpfte Prozesse für die

beiden genannten Bereiche jedoch nicht aus. Es ist von entscheidender Bedeutung,

dass das Team regelmäßig Feedback von den weiteren Beteiligten erhält. Nur so ist es

in der Lage, das gewünschte Endprodukt erfolgreich zu liefern und nötige

Änderungen effizient umzusetzen.

Anpassung an aktuelle Marktbedingungen Fast jeder Bereich der Softwarebranche muss heute mehr erreichen. Organisationen

stehen heute vor Problemen, für deren Lösung sie die eigenen Ansätze für

Anwendungserstellung, Support und Wartung verbessern müssen. In der

Softwarebranche erkennen wir folgende Dynamiken:

Ständige Verbesserung der Prozesse und Technologien führen zu neuen

Möglichkeiten, beispielsweise Cloud Computing.

Die Notwendigkeit, bei wachsender Vielfalt der Systeme und Umgebungsvariablen

trotzdem schneller Software zu entwickeln, steigert enorm die Komplexität von

Projekten.

Ressourcenknappheit und enge Zeitpläne erhöhen den Druck, neue Wege zu finden,

beispielsweise durch Outsourcing oder auch gerade dadurch, dass

Entwicklungskompetenz wieder zurück ins Unternehmen geholt wird.

Dadurch dass deutlich mehr Personen und Gruppen einbezogen werden müssen,

steigt die Kommunikationsmenge deutlich an.

ALM-Toolsets müssen diese Dynamiken abdecken. Sie müssen Teams darin

unterstützen, Ergebnisse über eine Vielzahl von Technologien schneller als bisher zu

liefern und gleichzeitig mit der Komplexität der Lösungen umzugehen. Sie müssen

außerdem, unabhängig von der Größe des Teams oder seiner geografischen

Verteilung, eine effektive Kommunikation über das gesamte Team hinweg

ermöglichen.


Weniger Ressourcenvergeudung Eine Vergeudung von Ressourcen und Arbeitszeit entsteht oftmals dann, wenn

Sollbruchstellen in den Workflows zwischen Teams bestehen. Typische Beispiele sind

schlecht definierte Übergabepunkte und ineffektive Prozesse, die eine Interaktion des

Teams behindern:

Wenn Individuen schlecht oder gar nicht in den Prozess einbezogen werden, führt

dies zu falsch gesetzten oder konkurrierenden Prioritäten.

Wenn wichtiger Kontext nur unvollständig erklärt werden kann, werden

Übergabepunkte zu Sollbruchstellen an denen Redundanzen und Missverständnisse

entstehen.

Ungewohnte Tools und Prozesse erzeugen Mehraufwand und erzwingen einen

ständigen Kontextwechsel bei Anwendern.

Mangelndes Verständnis für die Hintergründe und tatsächlichen Arbeitsweisen der

Beteiligten sorgt für geringe Akzeptanz der Prozesse und steigert drastisch den

Overhead und die Anzahl verlorener Produktivitätszyklen.

Erfolgreiche ALM-Systeme müssen sich speziell auf die Beseitigung solcher Probleme

konzentrieren. Dies ist nur über eine umfassende und realistisch umsetzbare

Integration möglich, die nicht nur die Entwickler einbezieht, sondern alle Beteiligten

des Application Lifecycle. Von der Designphase über die Entwicklung bis hin zum

Einsatz in der Produktivumgebung und der Wartung muss ein einzelner integrierter

Datenspeicher zur Verfügung stehen, über den für alle Beteiligten jederzeit ein

zuverlässiger Einblick in den Gesamtstatus und den Zustand des Projektes möglich ist.

Best Practices aus der agilen Entwicklung Agile Development-Ansätze und vor allem das Scrum-Modell sind mit der Zeit immer

populärer geworden. Wichtige Ziele dieser Ansätze sind eine deutliche Verbesserung

der Transparenz für das gesamte Projektteam, die Verbesserung der Zusammenarbeit

zwischen Teammitgliedern und eine starke Ausrichtung auf den tatsächlichen Nutzen

des Endproduktes für Kunden und Anwender.

In den agilen Ansätzen gibt es viele Best Practices. Diese können individuell umgesetzt

und auf fast jedes Projekt und jeden Prozess angewandt werden – inklusive formaler

Herangehensweisen wie CMMI oder traditioneller Herangehensweisen wie dem

Wasserfall-Modell. Entsprechende Best Practices sind zum Beispiel Product Backlogs,


Iterationen, Sprints, Daily Stand Ups, Task Boards, Burn Down Charts, Stakeholder

Feedback, Unit Testing und Pair Programming.

Abbildung 2: Agile Development-Ansätze sorgen durch das iterative Vorgehen für eine deutliche Verbesserung

der Transparenz für das gesamte Projektteam. Sie verbessern die Zusammenarbeit zwischen Teammitgliedern und

ermöglichen eine starke Ausrichtung auf den Nutzen für den Endanwender.

ALM-Lösungen müssen die Nutzung von Best-Practices aus der agilen Entwicklung

ermöglichen und gleichzeitig den momentan verwendeten Ansatz adaptieren und

unterstützen. Nur so ist es möglich, neue Best-Practices schrittweise einzuführen und

gleichzeitig zu skalieren.


Application Lifecycle Management mit Visual Studio Visual Studio vNext ist bereits die dritte große Innovationswelle unserer ALM-

Lösungen auf Basis von Visual Studio mit Team Foundation Server. Sehen wir uns die

bisherigen großen Wellen in der Entwicklung von Application Lifecycle Management

mit Visual Studio an:

Abbildung 3: Das Team zusammenbringen – Die ersten zwei wichtigen Innovationswellen haben viele Bereiche

des Teams miteinander verbunden und vertrauenswürdige und transparente Brücken für einen besseren

Informationsfluss geschaffen.

Die Basis: Teamzusammenarbeit mit Visual Studio 2005 und 2008

Bei der Erstveröffentlichung von Visual Studio Team System im Jahr 2005 lag unser

Augenmerk darauf, mit einem gemeinsamen Datenspeicher mit einem zentralen

Backlog für die Aktivitäten des gesamten Teams für mehr Übersicht zu sorgen: Team

Foundation Server ist das Herzstück von Visual Studio.

Der gemeinsame Datenspeicher war eng mit einem anpassbaren Entwicklungsprozess

integriert. Das System konnte so in verschiedenen Konfigurationen eingerichtet

werden und gleichzeitig individuelle Anforderungen berücksichtigen. Die Integration

von Entwicklungsumgebung und Datenspeicher sorgte dafür, dass Entwickler ihre

Aufgaben aus einem gemeinsamen Backlog bezogen. Nachdem sie die erforderlichen

Änderungen durchgeführt hatten, nutzen sie die integrierten Check-In-

Funktionalitäten, um die fertige Arbeit direkt über die Visual Studio-

Entwicklungsumgebung mit den entsprechenden Work-Items zu verknüpfen.

Auf diese Weise entstand ein transparenter Prozess, in dem Entwickler ihrer

tagtäglichen Arbeit nachgehen und mit minimalem Aufwand die Aktualität des

Projektplans sicherstellen konnten. Das Team konnte automatisierte Echtzeitberichte

nutzen, und das Projektmanagement-Team konnte seine gewohnten Tools wie


beispielsweise Microsoft Excel oder Microsoft Project zur Fortschrittsüberwachung

einsetzen.

Zweite Welle: Integration von Testern, Architekten und Eclipse

Bei der aktuellsten Produktversion Visual Studio 2010 lagen unsere Schwerpunkte auf

der Optimierung des Informationsflusses innerhalb des gesamten Teams und auf der

Verbesserung der Softwarequalität. Wir haben den Qualitätssicherungsprozess über

den Team Foundation Server nahtlos an das Entwicklungsteam angebunden und so

die Möglichkeit geschaffen, sowohl das Testen wie auch die Designphase eng in den

Entwicklungszyklus zu integrieren.

Mit von Grund auf neu entwickelten Tools sind die Tester aktiv in den

Entwicklungszyklus integriert. Mit Team Foundation Server arbeiten die eng

miteinander verzahnten Bereiche Entwicklung und Test nun auf ein gemeinsames Ziel

hin.

Die virtualisierte Testumgebung mit ihren integrierten Instrumenten zur

Qualitätssicherung sorgt für einen umfassenden Überblick des Projektfortschritts. Die

Tester können Fehler inklusive aller vom Entwickler zur Nachstellung benötigten

Metadaten sehr einfach festhalten. So müssen unvollständig beschriebene Fehler

weniger häufig zwischen den Teams hin und her zugewiesen werden und es werden

weniger Ressourcen für solche Vorgänge verschwendet.

Mit der Unterstützung für die Eclipse-Entwicklungsplattform unter Macintosh,

Windows und Linux stehen die Vorteile unserer Vision nun auch auf anderen

Plattformen zur Verfügung. Teams können so an einem umfangreicheren Portfolio aus

heterogenen Anwendungen arbeiten und die Vorteile einer gemeinsamen

Collaboration-Infrastruktur nutzen. Weitere Informationen zur Integration von Eclipse

in Visual Studio Team Foundation Server finden Sie online unter

www.microsoft.de/visualstudio/eclipse.

http://www.microsoft.de/visualstudio/eclipse


Visual Studio vNext: Ausweitung auf den ganzen Entwicklungszyklus und Einbeziehung neuer Gruppen Mit Visual Studio vNext verbessern wir den Informationsfluss zwischen Stakeholdern

und Development, also zwischen Kunden und Fachbereichen auf der einen Seite und

dem Entwicklungsteam auf der anderen Seite.

Die Softwarequalität wurde in allen Bereichen des Entwicklungszyklus verbessert – von

Check-in bis Sprint. Wir befreien das Team von ablenkenden Einflüssen und

unterstützen es durch die Automatisierung vieler häufig vorkommender Interaktions-

und Verwaltungsaktivitäten dabei, seine Aufmerksamkeit auf das Wesentliche zu

richten.

Sehen wir uns verschiedene Szenarien aus Visual Studio vNext an:

Agile Planungstools erlauben Transparenz über alle Planungsprozesse und beziehen

das gesamte Team ein. Sie sind flexibel einsetzbar, können individuell angepasst

werden und eignen sich für Teams jeder Größe – von 2 bis 20.000 und darüber

hinaus…

Schlanke Anforderungen („Lightweight Requirements“) bedeuten einen

natürlichen Weg, frühzeitig im Entwicklungsprozess wichtiges Feedback sammeln und

auswerten zu können.

Direktes Stakeholder Feedback dank smarter Nutzung gewohnter Werkzeuge stellt

sicher, dass Endanwender wie beispielsweise Kunden oder Fachabteilung direkt und

komfortabel Feedback geben können, welches dann ohne Umschweife in den

Entwicklungsprozess einfließt.

Agile Qualitätssicherung und kontinuierliches Testen stellen die Qualität im

Endprodukt sicher und verbessern die Codequalität dank Unterstützung für Code

Reviews, erweiterte Unit Test Frameworks und neuartige Methoden für exploratives

Testen.

Hilfreiche Werkzeuge für eine vorbildliche Abstimmung von Entwicklung und

Betrieb („Operations“) führen zu einer besseren Anbindung und mehr Einblick

zwischen den Abteilungen und dazu, dass Fehler auch in Produktivumgebungen

schneller gefunden und beseitigt werden.

Eine verbesserte User Experience der Werkzeuge erlaubt den einzelnen Personen,

sich mehr auf die Aufgaben zu konzentrieren, anstatt auf ungewohnte Prozesse und

Werkzeuge und dadurch effizienter zu arbeiten.


Agile Planungstools Im Verlauf eines Projektes muss nicht nur die geplante Arbeit erledigt werden. Es

kommt auch neuer Arbeitsaufwand hinzu – beispielsweise, weil neue Anforderungen

umgesetzt werden müssen, weil ein Problem in der Produktivumgebung entdeckt

wurde oder einfach weil ein Teammitglied ausfällt. Bei solchen Veränderungen muss

sich auch der Plan entsprechend ändern lassen. Agile Teams sind offen für

Änderungen („Change“) und können damit effizient umgehen.

Visual Studio vNext bringt innovative neue Werkzeuge, mit denen sich alle Beteiligten

– vom Entwickler bis zum Endanwender – hilfreich in den Planungsprozess einbringen

können. Die einzelnen Personen können dabei auf vertraute Werkzeuge und

Methoden zurückgreifen und werden nicht aus ihrem Arbeitsfluss herausgerissen.

Unsere Tools zwingen Sie nicht dazu, einen bestimmten Prozess umzusetzen.

Stattdessen können Sie Best Practices aus der agilen Entwicklung nutzen. Diese Best

Practices können Sie im für Sie passenden Umfang einsetzen. Sie sind in den Portfolio-

Managementtools integriert und bieten Ihnen die Möglichkeit, in geografisch weit

verteilten Teams zu arbeiten.

Abbildung 4: Pflegen des Produkt-Backlogs – Das Produkt-Backlog bietet einen übergreifenden Überblick zur

aktuellen Arbeit, der dynamisch sortiert und gruppiert werden kann. Die Kunden können so die Arbeit schnell

priorisieren und Abhängigkeiten und Beziehungen beschreiben.


Abbildung 5: Sprint-Planung – Nach der Priorisierung der Arbeit ist es Zeit zur Sprint-/Iterationsplanung, zur

Ermittlung der Aufgaben und zur Zuweisung der Arbeiten. Durch die vorherige Aufbereitung der erforderlichen Daten

machen die verbesserten Werkzeuge für Aufgaben im Team Web Access diesen Prozess einfacher. Sie vereinfachen

die Zuordnung und Aktualisierung. Die Sprint-Planungstools unterstützten das Team effektiv darin, die Arbeit auf die

verfügbaren Kapazitäten zu verteilen. In diesem Screenshot zeigen interaktive Balkendiagramme die Kapazität der

Teammitglieder an. So steht Ihnen ein Echtzeitfeedback zur Planaktualisierung zur Verfügung.

Abbildung 6: TaskBoard im Team Web Access – Mit dem TaskBoard können Sie den Status der Aufgaben

anzeigen. So ist es möglich, den Fortschritt eines Teams für die einzelnen Produkt-Backlog-Elemente zu betrachten

und einen schnellen Überblick über die verbleibende Arbeit zu gewinnen. Unabhängig von der ausgewählten Vorlage

für das Projekt nutzt das TaskBoard die Regeln aus der Prozessvorlage (beispielsweise Statusübergänge). Ein in das

TaskBoard integriertes Echtzeitdiagramm zeigt die verbleibende Arbeit an.


Abbildung 7: Anbindung an Project Server – Über die Anbindung stehen Ihnen aktuelle Informationen zur

Portfolio-Bearbeitung, zur Ausrichtung an den strategischen Zielen und zur Ressourcennutzung der

Softwareentwicklungsprojekte zur Verfügung. Diese Informationen basieren auf Daten aus verschiedensten Systemen.

Der Austausch von Projektinformationen zwischen den Teams erfolgt so völlig automatisch. Durch gemeinsame

Daten und Maßzahlen verbessert sich die Koordination zwischen Teams mit unterschiedlichen Arbeitsweisen.

Agile Teams können auch weiterhin mit Product-Backlogs und User-Stories arbeiten und der PMO kann weiterhin die

Ressourcen im Unternehmen verwalten.


Einfache Anforderungen Egal, ob es sich um eine neue Lösung oder die Erweiterung einer bestehenden Lösung

handelt: Um Anforderungen wunschgemäß umzusetzen, müssen die Teams mit den

beteiligten Interessengruppen zusammenarbeiten. Storyboards haben sich hier als

sehr gut geeignete und erprobte Verfahren erwiesen. Sie stellen sicher, dass bereits

vor der Codeentwicklung ein detailliertes Feedback zur Verfügung steht.

In Visual Studio vNext gibt es daher einen StoryBoard-Assistenten. Dieser Assistent

integriert ein Storyboard-Element in die PowerPoint-Multifunktionsleiste. So werden

Erstellung und Überprüfung eines Storyboards mit dem Rest des Teams verknüpft. Die

Teammitglieder können ein Storyboard erstellen und es dem Team und den

Interessengruppen zur Verfügung stellen. Ihnen steht eine Bibliothek mit

Steuerelementen für verschiedene Anwendungstypen und Tools zur Verfügung. Mit

diesen Steuerelementen stellen die Teammitglieder ein entsprechendes Feedback

bereit, das direkt in den Erstellungsprozess einfließen kann.

Abbildung 8 – Der StoryBoard-Assistent in PowerPoint bietet die Möglichkeit, die Anforderungen aller

Teammitglieder in einem bekannten Tool nachzubilden.

Mit den umfangreichen Features sind verschiedenste Storyboard-Elemente möglich:

• Grafische Designelemente

• Eingebettete Inhalte (inklusive Kontext-Folien)

• Screenshots und kleine Animationen

• In Bibliotheken gespeicherte Elemente

• Mastervorlagen vereinfachen das Erstellen mehrerer ähnlicher Ansichten


Die Werkzeuge zur Zusammenarbeit aus PowerPoint unterstützen den

Feedbackprozess nachhaltig:

• Präsentation der Konzepte für andere

• Versenden der Dokumente für Feedbackzwecke per E-Mail

• Ausdrucken der Dokumente

• Platzieren der Dokumente in einer Versionskontrolle

• Nutzung von gemeinsamen Bearbeitungstools

• Nutzung von Tools zur Anzeige über das Internet

Abbildung 9: Beispiele zu Storyboard-Folien – vier Beispiele zur Nutzung des StoryBoard-Assistenten. In diesen

Screenshots sehen Sie den Entwurf einer Windows Phone-Benutzeroberfläche, eine Webanwendung zur

Musikwiedergabe, eine SharePoint-Anwendung und Visual Studio.


Promptes Feedback Eine wichtige Voraussetzung für die konsistente Umsetzung von Anforderungen in der

Agilen Entwicklung ist das regelmäßige Feedback aller Beteiligten. Das Erkennen von

Problemen wird einfacher, wenn direkt mit der Lösung gearbeitet werden kann. Sie

sind dann in der Lage, bessere und schnellere Lösungsansätze zu finden. Entwickler

sind häufig der Meinung, dass sie genau das entwickelt haben, was der Kunde

verlangt hat. Wogegen der Kunde zum Projektende behauptet, er „hätte das Ganze

anders gemeint“.

Dieses Problem haben wir beim Entwurf von Visual Studio vNext sorgfältig bedacht.

Wir haben uns gefragt, wie Teams einfacher und schneller zu einem funktionierenden

Programmcode kommen können, um so ihre Backlogs für jeden Sprint-Zyklus an die

Anforderungen der Interessengruppen anzupassen. Dies kann in erster Linie durch das

Bereitstellen von Feedback zur Projektlaufzeit unterstützt werden. Wenn wir das

Design entsprechend verändern, kann Visual Studio vNext den Informationsfluss

zwischen den Interessengruppen und dem Team deutlich verbessern. Workflows aus

der Agilen Entwicklung werden genutzt, die Bereitstellung wird beschleunigt und

Risiken sowie die Verschwendung von Ressourcen werden minimiert.

Mit Visual Studio vNext stellen wir Tools bereit, mit denen alle Beteiligten direkt am

Entwicklungsprozess teilhaben können. Auf diese Weise erhalten die Teams ein

aussagekräftiges Feedback zu ihrem Backlog. Sie können sich so auf aktuelle

Aufgaben und auf das Feedback für die noch verbleibenden Aufgaben konzentrieren.

Abbildung 10: Abfrage des Feedbacks der Interessengruppen – Der Projektleiter definiert das Feedback, das er

von den Interessengruppen erhalten möchte, und stößt den Feedbackprozess dann per E-Mail an.


Abbildung 11: Zusammenstellung des Feedbacks auf einer Website – Das Feedbacktool für die

Interessengruppen zeichnet das Feedback über eine Website auf. Es bietet den Benutzern während der

Feedbackerstellung verschiedenste Interaktionsmöglichkeiten (beispielsweise Action-Scripts, Anmerkungen,

Screenshots, Audiodaten etc.).Die Beteiligten können auf diese Art und Weise umfangreiche und aussagekräftige

Daten an das Team weitergeben

.

Abbildung 12: Priorisierung und Berücksichtigung von Feedback – Wenn Feedbackinformationen eingehen,

dann priorisiert das Team diese und weist die entsprechende Arbeit für den nächsten Sprint-Zyklus verschiedenen

Teammitgliedern zu. Das Feedback verknüpft somit konkrete Aufgaben und adressiert die abzuleitenden Arbeiten an

das Team.


Agile Qualitätssicherung Die Qualität einer Software wird von jedem Entwicklungszyklus beeinflusst. Aufbauend

auf den Funktionalitäten von Visual Studio 2010, haben wir auf die Mittel zur

Verbesserung der Softwarequalität während der Erstellungsphase besonderen Wert

gelegt:

Einzelne Entwickler haben die Möglichkeit, sich zuerst auf das korrekte Unit-

Testing zu konzentrieren.

Es stehen Tools bereit, mit denen das Team bei neuem Programmcode oder

einem Refactoring von bestehendem Programmcode zusammenarbeiten kann.

Es stehen Tools zur Unterstützung des Exploratory-Testings bereit. Diese sorgen

für die Erkennung von Fehlern nach der Build-Erstellung.

Abbildung 13: Fortlaufende Unit-Tests – Bei der Softwareentwicklung geht es darum, auf dem richtigen Weg zu

bleiben. Der neue Unit Test Runner unterstützt dies, indem er während der Erstellung der Software entsprechende

Tests durchführt. Die Testergebnisse stehen direkt zur Verfügung und weisen auf Probleme direkt während der

Codeerstellung hin. Seit Visual Studio 2010 werden Test Impact-Analysen verwendet. Dabei werden die wichtigsten

Tests immer als Erstes ausgeführt


Abbildung 14: Code-Review in Aktion – Visual Studio vNext bietet Unterstützung bei Code-Reviews.

Teammitglieder können Feedback zu neuem Programmcode bereitstellen und ihre Kenntnisse mit dem Team teilen.

Wenn erforderlich, so können Code-Reviews als Qualitätskriterium für den Entwicklungsprozess eingesetzt werden. Im

Screenshot sehen Sie die hervorgehobenen Änderungen am Quellcode und die Kommentare der Teammitglieder zu

diesen Änderungen.

Abbildung 15: Code Clone Detection – Eine Überprüfung eines Projekts mit dem Ziel, häufig vorkommende

Codeblöcke per Refactoring in einen gemeinsam genutzten Codeblock auszulagern.

Die Erkennung nutzt eine von Microsoft Research entwickelte Technologie. Sie arbeitet mit einem weitmaschigen

Netz und erkennt so Codeblöcke mit ähnlichen Strukturen und Vorgehensweisen.

Die Suche arbeitet hierbei nicht nur vergleichend, sondern auch semantisch. Mit dieser Technik werden sowohl Copy-

Paste-Fehler als auch Codefragmente mit gleicher logischer Struktur und nur oberflächlichen Abweichungen

(beispielsweise Variablennamen) erkannt.

Als Suchergebnis steht ein Bericht zur Verfügung, mit dem das Team häufig vorkommende Codeteile überprüfen

kann.


Abbildung 16 - Exploratory Testing. Für gewöhnlich werden die wichtigsten Fehler während der ungezielten

Erkundung der Anwendung entdeckt.

Das Exploratory Testing in Visual Studio erstellt ein vollständiges Protokoll der Interaktion mit der zu testenden

Software. Sie können dann die relevanten Teile, die Sie zur Darstellung des Fehlers benötigen, aus dem Protokoll mit

Screenshots kombinieren. So wird das Problem exakt wiedergegeben.

Ausrichtung von Entwicklung und Betrieb Alle erfolgreichen Softwareprojekte kommen irgendwann in einer

Produktivumgebung zum Einsatz. Erst in diesem Moment wird der tatsächliche Nutzen

eines Softwareprojektes für das Unternehmen messbar. An diesem Punkt treten jedoch

häufig viele Fehler auf, die nur schwer zu reproduzieren sind. Oft erfährt das Team von

Fehlern in der Produktivumgebung, ist jedoch nicht in der Lage, die entsprechenden

Probleme außerhalb der Produktivumgebung nachzustellen, bzw. zu reproduzieren.

Dies führt zu Frustration bei den Benutzern und dem für den Betrieb der Lösung

verantwortlichen Team.

Mit Visual Studio vNext bieten wir Ihnen Integrationselemente, mit denen Sie einen

umfangreichen und nachvollziehbaren Workflow zwischen dem Entwicklungsteam

und dem Betriebsteam etablieren. Ein erstes entsprechendes Szenario wurde auf der

TechEd NA vorgestellt. Es gibt den Mitarbeitern aus dem Betriebsteam die

Möglichkeit, über System Center benötigte Daten an das Entwicklungsteam

weiterzugeben. Dieses kann die Fehler besser sichten und schneller ihren Ursprung im

Programmcode ermitteln. Diese Integration steht bereits als CTP (Community

Technology Preview) zur Verfügung.


In Visual Studio vNext bringen wir unsere erprobte IntelliTrace-Infrastruktur in die

Produktivszenarien ein, die wir bislang in Debugging-, Entwicklungs- und

Testumgebungen genutzt haben. So verbessern und intensivieren wir die

Zusammenarbeit von Entwicklern und Betriebsteams noch stärker. Dies findet nun in

der Erstellungsphase statt und bedeutet somit eine engere Verzahnung der

Interessengruppen untereinander. Dies führt zur Erhöhung der Softwarequalität, bei

gleichzeitiger Minimierung der möglichen Fehlerquellen.

Abbildung 17: Anwendungsfehler in der Produktivumgebung – In einer Anwendung in der Produktivumgebung

wird ein Problem entdeckt und im System Center ein Alarm erzeugt. Das Betriebsteam kann schnell feststellen, ob das

Problem mit der Anwendung selbst oder aber mit der Umgebung zusammenhängt.


Abbildung 18: Senden des Problems an das Entwicklungsteam – Wurde festgestellt, dass das Problem auf der

Anwendungsschicht zu finden ist, so leitet der Administrator das Problem über die integrierte Anbindung des Team

Foundation Server an das Entwicklungsteam weiter.

Abbildung 19: Umfangreiche Daten für die Entwickler – Es folgt die Sichtung des Problems durch den Projektleiter.

Dieser übergibt es an ein Mitglied des Entwicklungsteams. Der Aufgabenpunkt umfasst aussagekräftige Daten für den

Entwickler (Umgebungsdaten, ein Stack-Trace, AVICode-Telemetriedaten usw.). Der Entwickler kann so das Problem

schnell identifizieren und mit einem Klick direkt zur entsprechenden Codezeile springen. In Visual Studio vNext gehen

wir noch einen Schritt weiter. Es ist möglich, ein vollständiges IntelliTrace-Protokoll aus der Produktivumgebung

anzuhängen.


Verbessertes User Experience Als Erstes werden Sie wahrscheinlich die verbesserte User Experience von Visual Studio

vNext bemerken. Wir haben uns darauf konzentriert, viele der tagtäglich von den

Teammitgliedern durchgeführten Aufgaben zu vereinfachen. Unser Ziel war es, Ihnen

die Arbeit mit der Software möglichst angenehm zu gestalten. Dieses Ziel ist im Team

von großer Bedeutung, um die Verschwendung von Ressourcen zu vermeiden oder

zumindest zu reduzieren.

Abbildung 20: Context-Switching mit MyWork – Eine der schwersten Aufgaben für einen Entwickler ist der

Umgang mit Unterbrechungen (vor allem dann, wenn ihn diese dazu zwingen, den Kontext des Projektes und des

gerade bearbeiteten Codes zu wechseln). Solche Wechsel stellen eine permanente Quelle für Fehler und

Verzögerungen dar. MyWork nutzt einen neuen, aufgabenbasierten Ansatz, um die Arbeitsbereiche der Entwickler zu

vereinheitlichen. Wenn der Entwickler den Kontext wechselt, beispielsweise um einen dringenden Fehler zu beheben,

so fasst Visual Studio alle offenen Arbeiten aus dem aktiven Task automatisch zusammen. Ruft der Entwickler diesen

Task später wieder auf, wird die Arbeit direkt im Kontext wiederhergestellt.


Abbildung 21: Team-Explorer – Der Team-Explorer bindet die Visual Studio-IDE an den Team Foundation Server

an. In vNext wurde das Nutzererlebnis erheblich verbessert. Die vollständig asynchrone Kommunikation führt zu

stark beschleunigten Ladezeiten. Wir haben außerdem neue Standardansichten entwickelt, mit denen die für Sie

wichtigen Informationen hervorgehoben werden (beispielsweise Ihnen zugeordnete Aufgaben, der Build-Fortschritt,

Berichte und Fehler). Die verbesserte Suchfunktion unterstützt Sie darin, die benötigten Informationen schnell zu

finden.

Abbildung 22: Management der Aufgaben– Wir haben die Weboberfläche für den Team Foundation Server

vollständig überarbeitet (sie nutzt standardkonformes HTML). Wo möglich, nutzen wir Touch-Bedienelemente zur

natürlichen Interaktion. Auch die Leistung vom Team Web Access wurde verbessert – inklusive der Erstellung und

Pflege von Aufgaben.


Abbildung 23: Dialog für neue Aufgaben – Der Aufgabenbetrachter in Visual Studio wurde mit vNext erheblich

erweitert. Umfangreiche Texte und Bilder können in Aufgaben eingebettet werden, was die Qualität des Feedbacks

erheblich verbessert. Viele Standardfelder werden außerdem bereits vorab ausgefüllt.

Abbildung 24: Team Foundation Server mit Windows Azure – Wir haben den Team Foundation Server auf die

Windows Azure-Plattform gebracht. Ein Team kann das Produkt so innerhalb von nur 30 Sekunden einrichten.


Fazit Moderne und leistungsfähige Lösungen für das Anwendungsmanagement müssen

sich mit den Problemen befassen, die Teams daran hindern, ihr volles Potenzial

auszuschöpfen. Sie müssen entsprechende Möglichkeiten bieten:

Bessere Zusammenarbeit durch nahtlose Integration aller Rollen im Team

Rechtzeitiges und direkt umsetzbares Feedback verringert die

Verschwendung von Ressourcen

Benutzer werden dort abgeholt, wo sie sich befinden, ihre Arbeitsweise und die

gewohnten Werkzeuge werden in den Prozess integriert

Transparente und agile Best Practices, die nach Belieben übernommen

werden können

Abbildung 25: Zusammenbringen des gesamten Teams – Mit Visual Studio vNext bringen wir das Team durch

die Integration der natürlichen Arbeitsweisen Einzelner enger zusammen und verbessern den Austausch von

Informationen nachhaltig.

Visual Studio vNext ist ein wichtiger und richtiger Schritt, den gesamten

Entwicklungszyklus möglichst breit abzudecken. Diese breite Abdeckung ist für den

Erfolg von Projekten von entscheidender Bedeutung. Wir haben uns zudem darauf

konzentriert, ein ständiges Feedback im gesamten Entwicklungszyklus zu

gewährleisten. Nur so ist eine umfassende, produktive und skalierbare Interaktion

möglich, die für mehr Produktivität und weniger Risiken sorgt.

Wir freuen uns darauf, Ihnen und Ihrem Unternehmen unsere Fortschritte zu

demonstrieren. Die beste Möglichkeit, diese Fortschritte zu beurteilen, ist die

Übernahme der grundlegenden Technologien von Visual Studio 2010. Wenn Sie

weitere Informationen benötigen, besuchen Sie die Visual Studio-Website:

www.microsoft.de/visualstudio

http://www.microsoft.de/visualstudio



application ifecycle anagement mit visual studio v...

Documents