Application Lifecycle Management mit Visual Studio vNext
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
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.
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.
Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 2 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 3 von 28
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.
Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 4 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 5 von 28
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.
Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 6 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 7 von 28
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, Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 8 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 9 von 28
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 Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 10 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 11 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 12 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 13 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 14 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 15 von 28
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
Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 16 von 28Die 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.
Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 17 von 28Promptes 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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 18 von 28
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.
Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 19 von 28Agile 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
Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 20 von 28Abbildung 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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 21 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 22 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 23 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 24 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 25 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 26 von 28
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. Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 27 von 28
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
Whitepaper: Application Lifecycle Management mit Visual Studio vNext Seite 28 von 28Sie können auch lesen
