30.11.2012 Aufrufe

erni essentials SOFTWARE ENGINEERING - erni-consultants.com

erni essentials SOFTWARE ENGINEERING - erni-consultants.com

erni essentials SOFTWARE ENGINEERING - erni-consultants.com

MEHR ANZEIGEN
WENIGER ANZEIGEN

Erfolgreiche ePaper selbst erstellen

Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.

software engineering 1<br />

<strong>erni</strong> essentiaLs<br />

<strong>SOFTWARE</strong> <strong>ENGINEERING</strong>


enables & delivers<br />

oLiVer bLindebaCher<br />

architektur@<strong>erni</strong>.ch<br />

business Unit Leader<br />

bei <strong>erni</strong> schweiz ag<br />

VORWORT<br />

Die Abhängigkeit der Gesellschaft von IT-<br />

Systemen und deren Prozessunterstützung ist<br />

enorm und steigt stetig an. Dies macht das<br />

Konzipieren und Realisieren von IT-Systemen<br />

zu einem verantwortungsvollen Auftrag.<br />

Dieser Auftrag kann nur erfüllt werden,<br />

wenn Systemarchitekturen einem Prozess<br />

folgend und nach festen Prinzipien konzipiert<br />

werden. Der Schlüssel zum Erfolg in der<br />

Systementwicklung liegt in der interdisziplinären<br />

Zusammenarbeit, in der alle Aspekte<br />

eines Zielsystems berücksichtigt werden und<br />

eine adäquate Lösung konstruiert wird.<br />

Dieses ERNI Essential zeigt auf, wie die<br />

Komplexität in der Konzeption und Realisierung<br />

von IT-Systemen und den übergeordneten<br />

Strategien durch einen Architekturprozess<br />

sowie ausgewählte Prinzipien<br />

und Methoden reduziert und beherrschbar<br />

gemacht wird. Basierend auf unserer<br />

Erfahrung haben wir aus der Vielfalt von<br />

Theorien und Literatur eine systematische,<br />

kompakte und pragmatische Referenz für<br />

Architektur, Design und Implementation<br />

von Software zusammengestellt, die unabhängig<br />

von Technologien und Tools in Projekten<br />

und Organisationen anwendbar ist.<br />

<strong>erni</strong> – innovation in Process and technology<br />

software engineering 3<br />

1. EINFühRuNG 5<br />

2. ARchITEkTuRbEGRIFF 7<br />

2.1 architektur ist ein Kompromiss 8<br />

2.2 Qualitätsattribute 9<br />

2.3 architektenrolle 10<br />

3. ARchITEkTuRdImENSIONEN 13<br />

3.1 ebenen 14<br />

3.2 standpunkte 16<br />

3.3 aspekte 20<br />

3.4 sichten 24<br />

4. ARchITEkTuRpATTERNS 29<br />

5. ARchITEkTuRENTWuRF 33<br />

5.1 Prozessschritte 34<br />

5.2 architekturdokumentation 36<br />

5.3 Cartoon 38<br />

6. ARchITEkTuRbEWERTuNG 41<br />

7. dESIGNpRINzIpIEN 47<br />

8. dESIGNpATTERNS 53<br />

8.1 Layering 55<br />

8.2 Model-View-Controller 56<br />

8.3 facade 58<br />

9. ImplEmENTATION 61<br />

9.1 refactoring 63<br />

9.2 Unit-tests 64<br />

10. mEThOdEN FüR dIE umSETzuNG 69<br />

11. bEGRIFFE/GlOSSAR 75<br />

12. REFERENzEN 79


1. EINFühRuNG<br />

software engineering 5<br />

Der Entwurf von Softwaresystemen lässt sich grob in die Disziplinen<br />

Requirements Engineering, Architektur, Design, Implementation<br />

und Testen unterteilen. Das ERNI Essential «Software<br />

Engineering» beschäftigt sich dabei mit den drei Disziplinen<br />

Architektur, Design und Implementation. Für die Disziplinen<br />

Requirements Engineering und Testen verweisen wir auf die<br />

ERNI Essentials «Requirements Engineering» und «Testmanagement».<br />

Im Prozess zur Entwicklung einer Software oder eines Systems<br />

bewegt man sich im Laufe eines Projekts von einem abstrakten<br />

Lösungsansatz zu einer konkreten Lösung. Über die Disziplinen<br />

hinweg wird die Lösung durch die einzelnen Teams und Personen<br />

definiert und geformt. Dieses ERNI Essential folgt diesem<br />

Ansatz und zeigt die verschiedenen Schritte des Entwicklungsprozesses<br />

mit ausgewählten Beispielen zu Methoden, Prinzipien<br />

und Vorgehensweisen auf. Dabei wurden diejenigen Beispiele<br />

ausgewählt, die universell nutzbar sind und sich nicht auf eine<br />

bestimmte Technologie oder Domäne beschränken. Das vorliegende<br />

ERNI Essential folgt im inhaltlichen Ablauf den Prozessschritten<br />

von der Konzeption der Architektur über das Design bis<br />

zur Implementation bzw. zum Code. Im letzten Teil fragen wir<br />

uns, was einen guten Code ausmacht und welche Werkzeuge<br />

und Konzepte existieren, um einen solchen zu schreiben und zu<br />

erhalten. Ein Glossar und eine Referenzliste für weiterführende<br />

Literatur komplettieren dieses ERNI Essential.


2. ARchITEkTuRbEGRIFF<br />

software engineering 7<br />

Die Architektur ist die grundlegende Organisation eines Systems,<br />

verkörpert durch seine Komponenten und deren Kommunikation<br />

untereinander wie auch zur Umgebung. Die Architektur<br />

spiegelt die Prinzipien und wichtigsten Designentscheide<br />

wider, nach denen das System entworfen wurde. Der Fokus liegt<br />

dabei auf den für die Lösung signifikanten Elementen und deren<br />

Einbettung in die umliegenden Systeme.<br />

definition<br />

die architektur ist die grundlegende organisation eines systems,<br />

verkörpert durch seine Komponenten und deren Kommunikation<br />

untereinander wie auch zur Umgebung.<br />

Die Architektur einer Software adressiert in erster Linie die Kapselung<br />

der Daten, die Aufteilung in Komponenten und Programme,<br />

deren Zusammenspiel in Form von Prozessen und den Datenzugriff<br />

sowie die Interaktionen mit Drittsystemen. Die Architektur<br />

bildet dabei das Fundament für den Detailentwurf und<br />

stellt die Integration in das übergeordnete Gesamtsystem sicher.<br />

Es gibt nicht die richtige Architektur. Sie muss immer in Bezug<br />

zu den geforderten Qualitätsattributen, den verfügbaren Ressourcen<br />

und dem gegebenen Kostenrahmen gesehen werden.


Jedes System hat eine Architektur, auch wenn diese nicht formal<br />

dokumentiert ist. Ohne entsprechende Dokumentation in Form<br />

geeigneter Modelle lässt sich jedoch nur schwer oder zu spät feststellen,<br />

ob die gewählte Lösung den Qualitätsanforderungen<br />

genügt. Die Dokumentation bildet die Grundlage für die weitere<br />

Entwicklung und fungiert als eines der wichtigsten Kommunikationsmittel<br />

zwischen Auftraggeber, Projektleitung, Kundenvertretern<br />

(dem Geschäft) und Entwicklern. Die Architekturdokumentation<br />

stellt dabei ein gemeinsames Verständnis sicher.<br />

2.1 ARchITEkTuR IST EIN kOmpROmISS<br />

Abb. 1: arChiteKtUr aLs KoMProMiss<br />

Verfügbarer Kostenrahmen<br />

Verfügbarkeit<br />

erweiterbarkeit<br />

?<br />

bedienbarkeit<br />

Performance<br />

sicherheit<br />

Die Architektur ist das Ergebnis eines Kompromisses zwischen<br />

den oft gegenläufigen Qualitätsattributen. Die Kosten geben da-<br />

software engineering 9<br />

bei den möglichen Rahmen vor. So wirkt sich beispielsweise eine<br />

erhöhte Sicherheit negativ auf die Performance aus; die Verbesserung<br />

der Performance wirkt sich andererseits negativ auf die<br />

Erweiterbarkeit durch die Schaffung von Redundanzen aus. Die<br />

richtige und ausgewogene Berücksichtigung der Qualitätsattribute<br />

bildet ein Hauptaugenmerk der Architektur. Der gewählte<br />

Entwurf entscheidet über deren Erfüllungsgrad – heute wie auch<br />

in Zukunft. Bei der abschliessenden Architekturbewertung wird<br />

geprüft, ob die getroffenen Entscheidungen den relevanten Qualitätsanforderungen<br />

noch entsprechen und die gewählte Lösung<br />

als Ganzes damit zweckmässig ist.<br />

2.2 QuAlITäTSATTRIbuTE<br />

Bei Qualitätsattributen handelt es sich um einen Teil der nichtfunktionalen<br />

Anforderungen, die manchmal implizit erwartet<br />

werden und bei deren Absenz der spätere Anwender nicht zufrieden<br />

wäre. Es ist nicht das Fehlen einer bestimmten Funktion,<br />

sondern die nicht korrekte oder nicht effiziente Ausführung, die<br />

ein Ärg<strong>erni</strong>s für den Benutzer darstellt.<br />

wiChtig zU wissen<br />

architektur adressiert die Qualitätsattribute.


wesentLiChe QUaLitätsattribUte<br />

• Performance<br />

• Skalierbarkeit<br />

• Sicherheit<br />

• Bedienbarkeit<br />

• Verfügbarkeit<br />

• Integrierbarkeit<br />

• Änderbarkeit<br />

• Testbarkeit<br />

• Wartbarkeit<br />

Die Kosten, die zur Verfügung stehende Zeit und weitere nichtfunktionale<br />

Anforderungen wie z.B. Technologievorgaben sind<br />

zusätzliche, oft unterschätzte Einflussgrössen bei der Konzeption<br />

der Architektur und dem möglichen Erfüllungsgrad der Qualitätsattribute.<br />

2.3 ARchITEkTENROllE<br />

Der Architekt ist in erster Linie Vermittler zwischen den verschiedenen<br />

Interessengruppen, Verantwortlicher des Lösungskonzepts<br />

und Berater für Businessanalysten, Programmierer und<br />

Projektleiter. Die Rolle des Architekten verlangt eine grosse Portion<br />

Sozial- und Kommunikationskompetenz. Er muss sich in<br />

die Lage der Stakeholder versetzen und ihre Position verstehen<br />

können.<br />

software engineering 11<br />

Der Architekt steht in der direkten Verantwortung, eine optimale<br />

Umsetzung für den Auftraggeber in Bezug auf Funktionalität,<br />

Qualitätsattribute und Kosten zu finden und voranzutreiben.<br />

Nicht die technisch beste Lösung oder der Einsatz der neusten<br />

Technologie steht im Vordergrund, sondern die Erreichung der<br />

Projektziele. Es ist nicht immer eine einfache Aufgabe, das Mögliche<br />

zugunsten des zeitlich Machbaren zu opfern und Kompromisse<br />

auch unter schwierigen Bedingungen herbeizuführen.<br />

Zu einem Architekten entwickelt man sich im Laufe seines Arbeitslebens.<br />

Ein Studiengang IT-Architektur wird bis dato von<br />

Hochschulen leider nicht angeboten. Sogar Zertifizierungen<br />

sind erst in der Entwicklung. Folgende Erfahrungen und Fähigkeiten<br />

sollte ein Architekt besitzen. Es ist zu beachten, dass dies<br />

lediglich eine Auswahl darstellt.<br />

sKiLLs eines arChiteKten<br />

• Informatik- oder Ingenieurstudium<br />

• Weitreichende Erfahrungen als Entwickler<br />

• Ausgeprägte analytische und konzeptionelle Fähigkeiten<br />

• Kenntnisse über die aktuell verfügbaren Technologien sowie<br />

deren Vor- und Nachteile<br />

• Kommunikations- und Sozialkompetenz<br />

• Grundlegende Kenntnisse im Projektmanagement und im<br />

gesamten Entwicklungsprozess<br />

• Proaktive Vorgehensweise und Pragmatismus<br />

• Kompromissbereitschaft, aber auch Durchsetzungsvermögen


3. ARchITEkTuRdImENSIONEN<br />

software engineering 13<br />

In einem Unternehmen findet die IT-Architektur auf verschiedenen<br />

Ebenen statt. Die Architekturebenen gilt es durchgängig<br />

und vollständig zu planen und zu unterhalten. Mit Hilfe von<br />

Sichten und Standpunkten als Architekturdimensionen lassen<br />

sich die Ebenen in sich ganzheitlich und konsistent beschreiben<br />

(Abb. 2). Die Geschäftsebene, jedes System und jede Applikation<br />

müssen adäquat dokumentiert werden, beispielsweise in einem<br />

Architekturdokument, wie in Kapitel 5.2 beschrieben.<br />

Abb. 2: diMensionen Von it-arChiteKtUren<br />

sichten<br />

standpunkte<br />

geschäftsebene<br />

systemebene<br />

applikationsebene


3.1 EbENEN<br />

Architektur findet auf verschiedenen Abstraktionsebenen statt:<br />

Abb. 3: ebenen Von it-arChiteKtUren<br />

ebene<br />

geschäft<br />

technologie system<br />

Konzeptionell ausführung<br />

geschäftsleistung<br />

implementation<br />

wirkt auf verarbeitet<br />

geschäftsobjekt geschäftsprozess geschäftsrolle<br />

unterstützt<br />

geschäftsfunktion<br />

nutzt<br />

abgeleitet<br />

von<br />

stellt bereit<br />

Komponente<br />

abgeleitet<br />

von<br />

Klasse<br />

standpunkt<br />

geschäftsereignis<br />

service<br />

Modul<br />

applikationsservice<br />

infrastrukturservice<br />

subsystem<br />

Knoten<br />

ausgeführt<br />

auf<br />

software engineering 15<br />

Geschäftsebene: Die Geschäftsebene, auch Unternehmensarchitektur<br />

genannt, beschäftigt sich mit der langfristigen Geschäftsstrategie.<br />

Eine Organisation ist gekennzeichnet durch die<br />

ständige Anpassung an äussere Gegebenheiten und die Fähigkeit,<br />

rasch auf Veränderungen zu reagieren. Auf der Unternehmensebene<br />

wird eine bedarfsgerechte Kernprozessunterstützung<br />

durch die IT in einem kalkulierbaren Kostenrahmen angestrebt.<br />

Den Anforderungen und Dynamiken des jeweiligen Geschäftsfeldes<br />

gilt es auf Architekturebene Rechnung zu tragen. Diese<br />

Ebene hat strategischen Charakter.<br />

Systemebene: Die Systemebene beschreibt das in sich konsistente<br />

Zusammenspiel verschiedener Applikationen und Services.<br />

Ein häufig vorkommender Begriff auf der Systemebene ist<br />

Service-orientierte Architektur (SOA). Die SOA ermöglicht es,<br />

Geschäftsprozesse und Workflows aus Services unabhängig von<br />

den darunterliegenden Applikationen zu orchestrieren und so<br />

rasch auf Prozessänderungen zu reagieren.<br />

Applikationsebene: Die Applikationsebene beschäftigt sich mit<br />

der Implementation sowie der Anpassung von Applikationen,<br />

Modulen und Komponenten. Es handelt sich hier um die klassische<br />

Softwarearchitektur.<br />

Untere Ebenen verfeinern die Architekturvorgaben der darüberliegenden<br />

Ebenen. Jede Ebene nutzt mit Hilfe von Schnittstellen<br />

die Daten, Services und Komponenten der darunterliegenden<br />

Schicht, um daraus höherwertige Dienste zu bauen und anzubieten.<br />

Anpassungen auf einer unteren Ebene sollten keine Anpas-


sungen auf der darüberliegenden Ebene notwendig machen.<br />

Dies wird durch einen Top-down-Ansatz und die konsequente<br />

Verwendung von prozessunabhängigen Interfaces erreicht.<br />

Wrapperklassen und übergreifende Definitionen müssen vermieden<br />

werden.<br />

wiChtig zU wissen<br />

architektur findet auf verschiedenen ebenen statt.<br />

Jede ebene muss geplant und gelenkt werden.<br />

Alle diese Ebenen müssen konzipiert werden. Sichten und Standpunkte<br />

sind Methoden, um diese zu beschreiben und zu konkretisieren.<br />

Jeder Standpunkt und jede Sicht trägt zur Konkretisierung<br />

der jeweiligen Architektur bei.<br />

3.2 STANdpuNkTE<br />

Die Sicht auf eine Architektur ist abhängig vom Betrachtungsstandpunkt<br />

(Abb. 4). Die Stakeholder einer Architektur vertreten<br />

naturgemäss verschiedene Standpunkte in Abhängigkeit ihrer<br />

Rolle. Die Betrachtung einer Architektur aus drei Standpunkten<br />

hat sich in der Praxis bewährt:<br />

software engineering 17<br />

Abb. 4: standPUnKte zUr betraChtUng Von it-arChiteKtUren<br />

Konzeptioneller<br />

standpunkt<br />

Was<br />

sind die bestandteile des<br />

systems? (Design Time)<br />

ausführungsstandpunkt<br />

Wie<br />

ist der ablauf des systems?<br />

(Run Time)<br />

implementationsstandpunkt<br />

Wo<br />

wird das system ausgeführt?<br />

(Deploy Time)<br />

Konzeptioneller Standpunkt: Er beschreibt das System aus der<br />

logischen, funktionalen Perspektive. Im Zentrum steht die Aufteilung<br />

in Funktionsblöcke, deren Schnittstellen und Verbindungen.<br />

Der konzeptionelle Standpunkt fokussiert sich darauf, die<br />

Architektur in Begriffen der Domäne zu verstehen und auszudrücken<br />

sowie darzulegen, wie die Anforderungen erfüllt werden.<br />

Dies umfasst das logische Datenmodell und die Benutzerfürung.


TAb. 1: foKUs des KonzePtioneLLen standPUnKtes<br />

bzgL. der drei arChiteKtUrebenen<br />

Architekturebene Fokus<br />

geschäftsebene welche domänenspezifischen geschäftstreiber<br />

und Leistungen der organisation definieren das<br />

geschäftsobjektmodell?<br />

systemebene was für services, abgeleitet von den geschäftsobjekten,<br />

müssen durch das system bereitgestellt<br />

werden, und wie sind diese untereinander<br />

verbunden?<br />

applikationsebene aufzählen der Komponenten als kleinste<br />

konzeptionelle einheiten einer architektur<br />

und darstellen von deren funktionsweise sowie<br />

interaktionspfaden.<br />

Ausführungs-Standpunkt: Er schildert das zeitliche Verhalten,<br />

die Synchronisation und die Kommunikation innerhalb der<br />

Software. Das System wird aus dem Gesichtspunkt der Laufzeitumgebung<br />

betrachtet. Einen wichtigeren Teil bildet dabei das<br />

Aufzeigen des Kontroll- und Datenflusses. Die Architekturpatterns<br />

liefern hierzu die Basis für die Ausführungsmodelle. Zu<br />

diesem Standpunkt gehören im Weiteren die Abklärungen des<br />

Datenvolumens, das Transaktionsmanagement und die Wiederherstellung<br />

der Daten.<br />

TAb. 2: foKUs des aUsführUngs-standPUnKtes<br />

bzgL. der drei arChiteKtUrebenen<br />

Architekturebene Fokus<br />

software engineering 19<br />

geschäftsebene Mit welchen geschäftsprozessen soll auf die geschäftsereignisse,<br />

also die bedürfnisse der Kunden,<br />

reagiert werden? welche geschäftsfunktionen<br />

sind dazu notwendig?<br />

systemebene zu welchen weitgehend unabhängigen und<br />

parallel ausführbaren subsystemen lassen sich die<br />

services zusammenfassen? welche aufrufbaren<br />

funktionen stellen diese bereit?<br />

applikationsebene zu welchen Modulen werden die Komponenten<br />

zusammengefasst? benennen der einzusetzenden<br />

Middleware und technologie sowie der notwendigen<br />

infrastruktur.<br />

Implementations-Standpunkt: Er betrachtet das System aus<br />

dem Blickwinkel, wie es aufgebaut und verteilt wird. Dieser<br />

Standpunkt dient dazu, die Infrastruktur und die Systemkomponenten<br />

zu benennen und zu beschreiben sowie aufzuzeigen, aus<br />

welchen physischen Bausteinen das System besteht. Dies sind<br />

typischerweise Applikationen, binäre Pakete, Bibliotheken,<br />

Frameworks und Konfigurationsdateien. Der Implementations-<br />

Standpunkt definiert zudem die Codeorganisation in Pakete und<br />

Lieferobjekte.


TAb. 3: foKUs des iMPLeMentations-standPUnKtes<br />

bzgL. der drei arChiteKtUrebenen<br />

Architekturebene Fokus<br />

geschäftsebene welche geschäftsrollen und akteure des Unternehmens<br />

sind für die ausführung der geschäftsprozesse<br />

notwendig, und wie wird der Prozess im<br />

Unternehmen installiert und implementiert?<br />

systemebene durch welche applikationen und hardwarebausteine<br />

werden die subsysteme implementiert?<br />

wie wird kommuniziert, und welches ist die<br />

Laufzeitumgebung?<br />

applikationsebene auf welchen physikalischen geräten und<br />

servern laufen welche Module, wie sieht das<br />

netzwerk aus, und mit welchen hilfsmitteln<br />

wird entwickelt?<br />

3.3 ASpEkTE<br />

Jeder der drei Standpunkte betrachtet bestimmte Aspekte eines<br />

Systems. Ein solcher Aspekt beinhaltet die Beantwortung<br />

spezifischer Interessen bestimmter Stakeholder. Die folgende<br />

Aufzählung nennt mögliche Aspekte, die während des Architekturentwurfs<br />

abhängig vom jeweiligen Standpunkt zu adressieren<br />

sind:<br />

software engineering 21<br />

KonzePtioneLLer standPUnKt<br />

• Funktionalität: Welchen Zweck erfüllt die Lösung, und in<br />

welche Funktionsblöcke sowie Subsysteme teilt sich diese<br />

auf?<br />

• Ergonomie: Was ist die grundsätzliche Bedienungsphilosophie?<br />

Müssen bestimmte Auflagen zur Vermeidung von Fehlbedienungen<br />

beachtet werden, und wie ist beispielsweise das<br />

Produkt durch Personen mit einer körperlichen Behinderung<br />

zu bedienen?<br />

• Daten: Wie werden die Daten gespeichert, wie erfolgen das<br />

Backup und eine mögliche Wiederherstellung? Wie wird die<br />

Datenintegrität sichergestellt und der Zugriff geregelt?<br />

• Geschäftsregeln: Rahmenbedingungen, Gesetze, Patente<br />

und technische Limitationen schränken das mögliche Lösungsspektrum<br />

ein. Wie werden diese Auflagen erfüllt?<br />

aUsführUngs-standPUnKt<br />

• Gleichzeitigkeit: Viele Abläufe finden gleichzeitig statt und<br />

werden über verschiedene Mechanismen synchronisiert.<br />

Wie sehen diese aus, und wie wird das System gestartet und<br />

gestoppt?<br />

• Kommunikation: Wie kommunizieren die verschiedenen<br />

Modelle untereinander, und wie wird mit den Umsystemen<br />

kommuniziert? Welche Protokolle und Kommunikationspatterns<br />

sollen verwendet werden?<br />

• Sicherheit: Welche Sicherheitsauflagen sind zu berücksichtigen?<br />

Wie erfolgt die Authentifizierung und Autorisierung?<br />

Sind die Daten zu verschlüsseln, und wie schützt<br />

sich das System?


• Infrastruktur: Ist zusätzliche Hardware notwendig, oder<br />

wird bestehende Infrastruktur genutzt? Netzwerktopologie<br />

und Technologieabhängigkeiten sind zudem Fragen dieses<br />

Aspekts.<br />

iMPLeMentations-standPUnKt<br />

• Entwicklung: Welcher Bauplan liegt der Architektur zugrunde?<br />

Ist ein bestimmtes Framework notwendig, und gibt<br />

es einzuhaltende Technologie- und Codierungsrichtlinien?<br />

• Verteilung: Wie wird die Software verteilt und installiert?<br />

Ist der Vorgang reversibel und wenn ja wie? Wie erfolgt eine<br />

mögliche Migration der Daten?<br />

• Betrieb: Wie wird die Applikation betrieben, überwacht<br />

und konfiguriert? Wie sieht ein möglicher Support aus?<br />

• Wiederverwendung: Auf welcher Ebene und wie findet eine<br />

Wiederverwendung statt? Welche Komponenten werden eingekauft,<br />

welche selbst gebaut? Wie wird die Wiederverwendung<br />

organisatorisch sichergestellt?<br />

Die folgende Abbildung fasst diese zwölf Aspekte nach der Aufteilung<br />

in die drei Standpunkte grafisch zusammen:<br />

Abb. 5: asPeKte naCh standPUnKten<br />

Konzeptionell<br />

funktionalität<br />

ergonomie<br />

daten<br />

geschäftsregeln<br />

ausführung<br />

gleichzeitigkeit<br />

Kommunikation<br />

sicherheit<br />

Vollständigkeit<br />

infrastruktur<br />

Vertraulichkeit<br />

Verletzlichkeit<br />

Verfügbarkeit<br />

software engineering 23<br />

implementation<br />

entwicklung<br />

Verteilung<br />

betrieb<br />

störung<br />

Problem<br />

Change<br />

release<br />

Konfiguration<br />

wiederverwendung<br />

ooP<br />

sPL<br />

Cbd Mda<br />

soa Pattern


3.4 SIchTEN<br />

Die verschiedenen Aspekte eines Standpunktes werden aus drei<br />

Sichten beschrieben und in Diagrammen festgehalten: Struktur,<br />

Verhalten und Interaktion. Nach dieser Aufteilung sind auch die<br />

Diagramme in der Unified Modeling Language (UML) gruppiert.<br />

Abb. 6: organisation naCh siChten<br />

Verhalten<br />

aktivität<br />

zustand<br />

anwendungsfall<br />

Klasse<br />

Komponente<br />

Verteilung<br />

struktur<br />

sequenz<br />

Kommunikation<br />

Meldungen<br />

strUKtUr<br />

Die Struktur dokumentiert das Modell aus der statischen Sichtweise.<br />

Diese Sicht zeigt, aus welchen Elementen und Bausteinen<br />

ein System besteht. In der Unified Modeling Language werden<br />

für die Modellierung der Struktur Klassen, Pakete, Komponenten<br />

und Knoten verwendet. Die Klassen sind die kleinsten Teile, die<br />

zu Paketen und dann zu Komponenten zusammengefasst werden.<br />

Die statische Sichtweise ist im Grunde eine Aufzählung und<br />

interaktion<br />

software engineering 25<br />

Gruppierung der Bestandteile eines Systems. Die Struktur lässt<br />

sich durch die Darstellung der Klassen und Komponenten sowie<br />

die Verteilung auf die Laufzeitumgebung beschreiben. Diese<br />

Sichtweise sagt jedoch nichts darüber aus, wie das System funktioniert<br />

oder sich über die Zeit verhält.<br />

VerhaLten<br />

Das Verhalten wendet sich dem dynamischen Teil eines Systems<br />

zu. Es wird aufgezeigt, wie sich das System oder dessen Komponenten<br />

über die Zeit verhalten, um bestimmte Aufgaben zu erfüllen.<br />

Der Fokus liegt dabei auf einem ausgewählten Baustein<br />

der statischen Sichtweise. Die UML-Elemente zur Verhaltensmodellierung<br />

sind Zustände, Aktivitäten, Meldungsflüsse bzw. Zustandsübergänge<br />

und Anwendungsfälle. Zustände und deren<br />

gleichnamige Diagramme veranschaulichen das Verhalten als<br />

ein Reagieren auf äussere Ereignisse aus einem stabilen Zustand<br />

heraus. Aktivitäten hingegen beschreiben eine sequenzielle Abfolge<br />

von Tätigkeiten, die eine Komponente bis zu einem bestimmten<br />

Endpunkt ausführt. Anwendungsfälle schildern hingegen<br />

eine Abfolge von Interaktionen zwischen einem Benutzer<br />

und dem System.<br />

interaKtion<br />

Die Interaktionen sehen das System als einen Fluss von Meldungen.<br />

Es wird dargelegt, welche Meldungen zwischen den statischen<br />

Elementen fliessen und wie diese zeitlich zusammenhängen.<br />

Im Gegensatz zur Verhaltenssichtweise liegt der Schwerpunkt<br />

auf dem Zusammenspiel der Komponenten von aussen<br />

gesehen. Betrachtet die dynamische Sicht das Verhalten eines


einzelnen Bausteins oder des Systems isoliert, so zeigt die Interaktionssicht<br />

den dabei stattfindenden Meldungsaustausch zwischen<br />

diesen Bausteinen auf. Die Elemente der Interaktionssicht<br />

in UML sind Sequenz- und Kommunikationsdiagramme. Beide<br />

bilden den zeitlichen Meldungsverlauf ab und illustrieren, welche<br />

Spur die Verarbeitung eines bestimmten Ereignisses hinterlässt.<br />

Mit der Beschreibung der Interaktionen lassen sich komplexe<br />

Zusammenhänge zwischen den Bausteinen jeder Abstraktionsebene<br />

ausdrücken. So lässt sich die Reaktion des Systems auf einzelne<br />

Szenarien illustrieren, indem der Meldungspfad durch das<br />

System aufgezeigt wird.<br />

software engineering 27


4. ARchITEkTuRpATTERNS<br />

software engineering 29<br />

Architekturpatterns definieren grundlegende Strukturen und<br />

Patterns, nach denen ein System aufgebaut ist. Sie charakterisieren<br />

hauptsächlich die Art und Weise der Kommunikation zwischen<br />

den relevanten Elementen eines Systems (Abb. 7).<br />

Die Liste möglicher Architekturpatterns ist keine fixe Grösse und<br />

hängt vom jeweiligen Betrachter ab. Neben den klassischen Patterns<br />

wie «Pipe-and-Filter,» «Client-Server», «Peer-to-Peer» und<br />

«Publish-Subscribe» finden sich viele weitere Ansätze wieder,<br />

basierend auf einem gemeinsamen Bus, auf dem Schichtenmodell<br />

und den Ereignis-, Ressourcen- oder Service-orientierten Architekturen.<br />

Viele Patterns finden sich in einer etwas anderen<br />

Bezeichnung und als auf die Problemstellung des Softwareentwurfs<br />

adaptierte Konzepte als Designpatterns wieder.<br />

Abb. 7: arChiteKtUrPatterns<br />

monolith<br />

publish-Subscribe<br />

client-Server<br />

Client<br />

peer-to-peer<br />

server<br />

pipe-and-Filter<br />

Shared-data<br />

filter


wiChtig zU wissen<br />

architekturpatterns beschreiben einen grundsätzlichen<br />

Lösungsansatz oder ein Kommunikationskonzept.<br />

die aM häUfigsten eingesetzten arChiteKtUrPatterns sind:<br />

• Monolith: Die aus einem Guss bestehende Applikation ist,<br />

insbesondere für lokal zu installierende Anwendungen, ein<br />

gängiges Pattern.<br />

• Client-Server: Ein Server bietet Dienste an, die vom Client über<br />

ein klar definiertes Interface aufgerufen und vom Server sofort<br />

(synchron) oder zeitverzögert (asynchron) beantwortet werden.<br />

• Pipe-and-Filter: Dieses Architekturpattern skizziert eine<br />

nacheinander geschaltete Reihe von Verarbeitungspunkten,<br />

den Filtern, verbunden durch Pipes. Dabei funktioniert jeder<br />

Filter ohne Wissen des Vorgängers und Nachfolgers.<br />

• Publish-Subscribe: Der Subscriber meldet sich beim Publisher<br />

an, um im Ereignisfall aufgerufen zu werden. Der Publisher<br />

kann mehrere Subscriber bedienen, und die Zustellung<br />

der gewünschten Daten erfolgt asynchron.<br />

• Peer-to-Peer: Das System besteht aus einer beliebigen Anzahl<br />

von Knoten (Peers), die frei untereinander kommunizieren.<br />

Bei diesem Ansatz gibt es im Gegensatz zum Client-Server<br />

kein steuerndes, zentrales System.<br />

software engineering 31<br />

• Shared-Data: Im Zentrum stehen persistente Daten, auf die<br />

mehrere Applikationen zugreifen. Diese Datenbank beinhaltet<br />

keine Geschäftslogik und dient lediglich dem asynchronen<br />

Datenaustausch und der Speicherung der Daten.


5. ARchITEkTuRENTWuRF<br />

software engineering 33<br />

Der Architekturentwurf verläuft nach folgender Vorgehensweise:<br />

Abb. 8: arChiteKtUrProzess<br />

Cartoon<br />

software requirements<br />

specification<br />

architekturdokument<br />

aktivitäten<br />

artefakte<br />

referenzen<br />

1.<br />

2.<br />

3.<br />

4.<br />

5.<br />

6.<br />

7.<br />

8.<br />

9.<br />

akzeptiert<br />

stakeholder<br />

identifizieren<br />

interessen<br />

erfassen<br />

Kontext<br />

definieren<br />

input<br />

konsolidieren<br />

szenarien<br />

identifizieren<br />

best Practices<br />

und Vorgaben<br />

identifizieren<br />

architekturkandidaten<br />

entwerfen<br />

architekturoptionen<br />

evaluieren<br />

architektur<br />

bewerten<br />

nicht akzeptiert<br />

Vision<br />

rahmenbedingungen<br />

referenzarchitektur<br />

architekturpatterns<br />

andere Projekte<br />

architektur<br />

10.<br />

überarbeiten


5.1 pROzESSSchRITTE<br />

1. Stakeholder identifizieren: Wie beim Anforderungsma-<br />

nagement ist die Berücksichtigung der relevanten Stakeholder<br />

entscheidend, um die Interessen aller Betroffenen<br />

einbeziehen zu können. Neben den primären Nutzern<br />

sind es auch Betreiber, Entwickler und Gremien, die Standards<br />

und Strategien vorgeben.<br />

2. Interessen erfassen: Die Interessen und Aspekte der Stakeholder<br />

abhängig von ihrem Standpunkt erfassen und priorisieren.<br />

Dies geschieht idealerweise mittels mehrerer Workshops.<br />

3. Kontext definieren: Den Projektkontext abstecken und damit<br />

festlegen, was Teil des Systems sein wird. Hierzu gehören<br />

auch die Identifikation der relevanten Umsysteme und<br />

die Beschreibung der Schnittstellen zu diesen.<br />

4. Input konsolidieren: Anwendungsfälle und SRS (Software<br />

Requirements Specification) müssen verstanden werden und<br />

in Bezug auf die Architektur widerspruchsfrei sein.<br />

5. Szenarien identifizieren: Szenarien sind konkrete Abläufe,<br />

die jeweils auf einen oder mehrere Architekturaspekte<br />

fokussiert sind. Im Gegensatz zu Anwendungsfällen beschreiben<br />

Szenarien genau eine mögliche Abfolge durch<br />

das System.<br />

software engineering 35<br />

6. Best Practices und Vorgaben identifizieren: Beim Entwurf<br />

sind bekannte Architekturpatterns und Lösungen<br />

aus anderen Projekten hinzuzuziehen. Allenfalls müssen<br />

Referenzarchitekturen oder anderweitige Vorgaben und<br />

Rahmenbedingungen berücksichtigt werden.<br />

7. Architekturkandidaten entwerfen: Erstellen einer ersten,<br />

groben Architektur, die die wichtigsten Komponenten und<br />

Beziehungen aufzeigt. Die Architektur wird durch die verschiedenen<br />

Sichten beschrieben, weiter verfeinert und im<br />

Architekturdokument festgehalten.<br />

8. Architekturoptionen evaluieren: Die zuvor gewählte<br />

Architektur wird hinsichtlich der geforderten Qualitätsattribute<br />

geprüft. Dies geschieht anhand der definierten Szenarien<br />

mit Hilfe von Walkthroughs, Prototypen oder Tests mit<br />

einem Programmskelett.<br />

9. Architektur bewerten: Die Architektur wird durch die<br />

Stakeholder geprüft. Allenfalls findet eine Validierung der<br />

Architektur durch Methoden wie ATAM statt.<br />

10. Architektur überarbeiten: Basierend auf den Ergebnissen<br />

der Validierung, speziell den Risiken und den sensitiven<br />

Punkten, wird die Architektur überarbeitet und werden die<br />

Modelle allenfalls verfeinert.


5.2 ARchITEkTuRdOkumENTATION<br />

Das Ergebnis des Architekturentwurfs ist das Architekturdokument<br />

(siehe Tab. 4 und 5), das neben der Klärung der grundsätzlichen<br />

Ziele die bereits besprochenen Aspekte aus den verschiedenen<br />

Standpunkten adressiert. Es hat folgenden Aufbau:<br />

TAb. 4: aUfbaU des arChiteKtUrdoKUMents (1)<br />

Thema beschreibung<br />

Management<br />

summary<br />

zusammenfassung des dokuments auf maximal<br />

einer seite, welche die wichtigsten Punkte<br />

beleuchtet.<br />

systemkontext abgrenzung des Projekts und ziehen der<br />

systemgrenzen. hierzu eignet sich neben einer<br />

textuellen beschreibung die darstellung eines<br />

Kontextdiagramms. das system ist dabei eine<br />

blackbox, und alle drittsysteme, mit denen<br />

kommuniziert wird, sind externe entitäten.<br />

Projektziele das eigentliche Projektziel und die wichtigsten<br />

anforderungen an das system werden wiederholt.<br />

dabei wird auf das Visionsdokument<br />

bezug genommen.<br />

generelle<br />

architekturprinzipien<br />

auflistung von generellen Prinzipien und überlegungen,<br />

auf denen die architektur aufgebaut<br />

ist. entscheidungen sind zu begründen und<br />

zu dokumentieren, damit sie für nachfolgende<br />

Leser nachvollziehbar sind.<br />

TAb. 5: aUfbaU des arChiteKtUrdoKUMents (2)<br />

Thema beschreibung<br />

software engineering 37<br />

sichten das system wird aus dem blickwinkel der Konzeptions-,<br />

ausführungs- und implementations-standpunkte<br />

modelliert. dabei werden die relevanten<br />

architekturaspekte betrachtet.<br />

Prototyp Kritische aspekte in einem Prototyp verifizieren<br />

zu lassen, ist oft eine einfache und effiziente<br />

Methode, um Unsicherheiten zu reduzieren und<br />

komplexe zusammenhänge zu veranschaulichen.<br />

das architekturdokument nimmt bezug auf die<br />

ergebnisse der Prototypen.<br />

Qualitätsattribute auflistung der Qualitätsattribute und beschreibung,<br />

wie diese durch die gewählte architektur<br />

sichergestellt werden.<br />

wichtige<br />

szenarien<br />

die wichtigsten fälle, die das system durchlaufen,<br />

werden kurz skizziert. gerade solche konkrete<br />

abläufe helfen, die eher abstrakte form eines<br />

Modells besser zu verstehen.


5.3 cARTOON<br />

Verständnis beginnt Mit eineM biLd!<br />

Abb. 9: systeMabgrenzUng aLs Cartoon<br />

GpS-Satelliten provider<br />

internet<br />

gPs-signal<br />

gPrs/UMts · staumeldungen<br />

· staumeldungen<br />

Navigationsgerät<br />

digital audio broadcast<br />

· staumeldungen<br />

· sperrungen<br />

Radiostation<br />

Die Architektur und ihre Dokumentation sind in erster Linie<br />

Mittel zur Kommunikation. Nichts ist stärker als eine gemeinsame<br />

Vision und Vorstellung über das zukünftige System. Dazu ist<br />

ein Cartoon (Abb. 9) ein wichtiges Hilfsmittel, das in jedem Fall<br />

zur Kommunikation und Veranschaulichung verwendet werden<br />

sollte. Der Bau eines Systems beginnt im Idealfall mit dieser einfachen<br />

und prägnanten Zeichnung, an der zukünftig viele Diskussionen<br />

beginnen werden. Diese Zeichnung oder dieser Cartoon<br />

zeigt mit allgemein verständlichen Symbolen die wichtigsten<br />

Elemente des Lösungsentwurfs auf.<br />

software engineering 39


6. ARchITEkTuRbEWERTuNG<br />

Abb. 10: arChiteKtUrbewertUngsProzess<br />

Qualitäts-<br />

merkmale<br />

1. geschäftsziele<br />

präsentieren<br />

2. architektur<br />

präsentieren<br />

3. Qualitätsbaum<br />

erstellen<br />

4. Qualitätsattribute<br />

bewerten<br />

5. szenarien identifizieren<br />

und<br />

priorisieren<br />

6. architektur-<br />

ansätze identifizieren<br />

software engineering 41<br />

sensitive Punkte<br />

und Kompromisse<br />

7. analyse nicht-risiken<br />

risiken<br />

aktivitäten<br />

artefakte<br />

Viele Softwareanwendungen müssen frühzeitig ersetzt werden, da<br />

sie den Qualitätsattributen nicht oder nicht mehr genügen. Für<br />

den Lebenszyklus einer Software ist eine ausgewogene Architektur<br />

erfolgsentscheidend. Sie muss den heutigen wie auch den zukünftigen<br />

Anforderungen nach Zuverlässigkeit, Skalierbarkeit, Performance<br />

und Erweiterbarkeit Rechnung tragen. Der Architekturentwurf<br />

soll mit einer Architekturbewertung frühzeitig hinsichtlich<br />

der Erfüllung der gestellten Anforderungen überprüft werden<br />

(Abb. 10). Die relevanten Qualitätsattribute werden den getroffenen<br />

Designentscheiden gegenübergestellt. Dabei werden die Qualitätsattribute<br />

in messbare Einzelanforderungen aufgegliedert und<br />

nach deren Relevanz und Auswirkung bewertet (Tab. 6, 7 und 8).


TAb. 6: ProzesssChritte der arChiteKtUrbewertUng (1)<br />

Task beschreibung<br />

1. geschäftsziele<br />

präsentieren<br />

2. architektur<br />

präsentieren<br />

3. Qualitätsbaum<br />

erstellen<br />

der Projektverantwortliche präsentiert die<br />

wichtigsten funktionalen anforderungen, die<br />

Projektziele, die technischen, wirtschaftlichen<br />

und politischen rahmenbedingungen sowie<br />

die wichtigsten stakeholder und Qualitätsansprüche.<br />

der architekt präsentiert die architektur<br />

anhand der verschiedenen standpunkte und<br />

erläutert daran die funktionsweise der gewählten<br />

Lösung.<br />

die Qualitätsattribute lassen sich in die<br />

hauptkategorien Performance, wartbarkeit,<br />

erweiterbarkeit, sicherheit, skalierbarkeit und<br />

bedienbarkeit aufteilen und diese wiederum in<br />

quantifizierbare anforderungen. das ergebnis<br />

ist ein baum, dessen äste die kleinsten nichtfunktionalen<br />

anforderungen darstellen, die es<br />

zu bewerten gilt.<br />

software engineering 43<br />

TAb. 7: ProzesssChritte der arChiteKtUrbewertUng (2)<br />

Task beschreibung<br />

4. Qualitätsattribute<br />

bewerten<br />

die zuvor identifizierten Qualitätsattribute werden<br />

nach ihrem geschäftlichen nutzen hin beurteilt.<br />

dabei werden die äste des Qualitätsbaums nach<br />

ihrer relevanz für den erfolg der applikation<br />

und den Kosten für deren erreichen bewertet. es<br />

genügt, wenn bei der beurteilung zwischen high<br />

(H), Medium (M) und Low (L) unterschieden wird.<br />

das folgende beispiel sagt aus, dass die relevanz<br />

für eine antwortzeit < 1 s Medium ist und die<br />

Kosten, um dies zu erreichen, Low sind.<br />

beispiel für einen Qualitätsbaum:<br />

Performance<br />

Latenz<br />

durchsatz<br />

relevanz Kosten<br />

(HM, L) antwortzeit < 1 s<br />

(HM, H) > 1000 benutzer


TAb. 9: ProzesssChritte der arChiteKtUrbewertUng (3)<br />

Task beschreibung<br />

5. szenarien<br />

identifizieren<br />

und priorisieren<br />

6. architekturansätze<br />

identifizieren<br />

hier wird nicht mehr nur die erfüllung einzelner<br />

Qualitätsmerkmale beurteilt, sondern es werden<br />

szenarien entwickelt, die das zu bauende<br />

system als ganzes betreffen. ein szenario<br />

beschreibt die art und weise, wie das system<br />

einen konkreten fall abarbeitet.<br />

bei der identifizierung der architekturansätze<br />

werden die architekturstile, die designpatterns<br />

und die gewählten technologien ermittelt, die<br />

zur anwendung kamen.<br />

7. analyse es wird nun geprüft, inwieweit die architekturansätze<br />

die zuvor gewichteten Qualitätsattribute<br />

und die signifikanten szenarien zu erfüllen<br />

vermögen. das ergebnis der architekturanalyse<br />

ist die auflistung und bewertung der identifizierten<br />

risiken, der sensitiven Punkte und<br />

der notwendigen Kompromisse. es wird keine<br />

architektur geben, welche die geforderten<br />

aspekte in ihrer gesamtheit zu erfüllen vermag.<br />

es ist jedoch wichtig, die risiken zu kennen.<br />

software engineering 45


7. dESIGNpRINzIpIEN<br />

software engineering 47<br />

Abb. 11: abhängigKeiten zwisChen designPrinziPien<br />

realisiert durch<br />

abstraktion<br />

ausprägung<br />

von<br />

Lose<br />

führt zu erhöht<br />

Kopplung<br />

hohe<br />

Kohäsion<br />

Modularität<br />

vereinfacht<br />

Konsistenz<br />

realisiert durch<br />

geheimhaltung<br />

ausprägung von<br />

entwurf für<br />

Veränderungen<br />

erhöht<br />

erhöht<br />

separation<br />

of Concern<br />

ausprägung<br />

von<br />

Dieses Kapitel beschäftigt sich mit den Merkmalen, die eine Architektur<br />

oder ein Softwaredesign als gut oder schlecht qualifizieren.<br />

Eine Architektur dient in erster Linie der optimalen Erfüllung<br />

der vorgängig beschriebenen Qualitätsattribute. Wie beim<br />

Schreiben einer Zeile Code, so gelten auch in der Architektur<br />

und im Softwaredesign grundlegende Prinzipien (Abb. 11). Die<br />

Berücksichtigung dieser Prinzipien – so allgemein sie auch sein<br />

mögen – bildet das Fundament jeder guten Architektur. Dies gilt<br />

heute bei Systemen von stets höherer Komplexität mehr denn je.


aUf VeränderUngen aUsgeriChteter entwUrf<br />

Auch in der Softwareentwicklung gilt, dass die Veränderung die<br />

einzige Konstante ist. Oft existieren hinsichtlich der technischen<br />

Machbarkeit nicht quantifizierbare Unsicherheiten. Diese<br />

erfordern eine Anpassung des ursprünglichen Entwurfs. Zudem<br />

muss das System auch zukünftigen Anforderungen genügen, die<br />

heute noch nicht abschätzbar sind. Die Fähigkeit, flexibel auf<br />

solche Veränderungen zu reagieren, ist ein entscheidender Erfolgsfaktor<br />

für moderne Systeme. Die lose Kopplung und die eng<br />

damit verbundenen Ansätze einer Komponenten- und Serviceorientierten<br />

Architektur sind Schlüsselfaktoren im Softwareentwurf.<br />

Die Abhängigkeit von herstellerspezifischen Technologien<br />

und Programmiersprachen ist dabei nicht zu unterschätzen. Applikationen<br />

haben nicht selten eine Lebensdauer von einem<br />

Jahrzehnt und mehr, und die gewählte Technologie sollte diesem<br />

Umstand Rechnung tragen.<br />

seParation of ConCern<br />

Separation of Concern (SoC) folgt dem Grundsatz «Teile und herrsche»,<br />

indem ein gegebenes Problem in Teilprobleme zerlegt wird,<br />

die getrennt voneinander gelöst werden können. Bei der Separation<br />

werden Dinge nach ihrem Zweck zusammengefasst, so dass<br />

sich diese in Bezug auf ihre Funktionalität minimal überlappen.<br />

Das Prinzip ermöglicht damit ebenso, ein Gesamtproblem arbeitsteilig<br />

zu behandeln. Die Trennung erfolgt nach funktionalen oder<br />

technischen Gesichtspunkten. Aus der fachlichen Sicht sind dies<br />

Subsysteme, die weitgehend unabhängig voneinander funktionieren.<br />

Aus dem technischen Blickwinkel sind dies Aspekte wie<br />

Performance, Sicherheit, Nachvollziehbarkeit und Nutzbarkeit.<br />

software engineering 49<br />

geheiMhaLtUng<br />

Geheimhaltung oder Information Hiding ist das Prinzip, der<br />

Aussenwelt nur so viel preiszugeben, wie gerade notwendig ist.<br />

Interne Datenstrukturen und Algorithmen werden verborgen.<br />

In objektorientierten Sprachen wird der Zugriff auf die internen<br />

Daten durch die darauf anzuwendenden Operationen geschützt.<br />

Beim Design der Schnittstellen ist darauf zu achten, dass mit den<br />

übergebenen Daten nicht implizit Interna über Datenmodelle<br />

oder eingesetzte Technologien weitergegeben werden. Heutige<br />

Werkzeuge ermöglichen beispielsweise auf einfache Weise,<br />

Strukturen einer Datenbank direkt an die Präsentationsschicht<br />

weiterzuleiten. Damit entsteht jedoch eine enge Kopplung zwischen<br />

Datenbank und Präsentationsschicht.<br />

abstraKtion<br />

Abstraktion ist das bewusste Auslassen bestimmter Informationen<br />

und Teilaspekte, um bestimmte Eigenschaften in der jeweiligen<br />

Betrachtungsebene hervorzuheben. Erst die Summe aller<br />

Ansichten ergibt wieder ein vollständiges Bild des Systems.<br />

Abstraktion findet auch auf hierarchischer Ebene statt, indem<br />

Einzelheiten der darunterliegenden Ebene ignoriert werden, um<br />

Gesamtzusammenhänge zu veranschaulichen. Die Kunst der<br />

Abstraktion ist es, die richtigen Dinge wegzulassen, um die wesentlichen<br />

Eigenschaften der jeweiligen Betrachtungsebene unmissverständlich<br />

zu erkennen.<br />

ModULarität<br />

Modularität ist ein Baukastenprinzip: Aus einzelnen Elementen<br />

oder eben Bausteinen entsteht eine übergeordnete Baugruppe,


die mehr ist als ihre Einzelteile. Von oben betrachtet wird das<br />

System mit umgekehrten Vorzeichen schrittweise in voneinander<br />

getrennte Bausteine zerlegt (Abb. 12).<br />

Konsistenz<br />

Strukturen, Vorgehensweisen und Entwurfsentscheidungen<br />

sollten einheitlich und durchgehend sein. Punktuelle Ausnahmen<br />

und Umgehungslösungen sind zu vermeiden. Dieses auch<br />

als konzeptionelle Integrität bezeichnete Prinzip lässt sich an<br />

einem konsistenten, in sich widerspruchsfreien Entwurfsgedanken<br />

erkennen.<br />

Abb. 12: ModULarisierUngsstUfen<br />

system<br />

daten & routinen<br />

Klasse<br />

subsysteme<br />

software engineering 51<br />

Lose KoPPLUng<br />

Die zuvor beschriebenen Prinzipien basieren alle auf den Regeln<br />

geringer Kopplung und hoher Kohäsion. Dabei ist die Kopplung<br />

das Mass der Abhängigkeit eines Elementes von seiner Umgebung<br />

und die Kohäsion der Grad des inneren Zusammenhalts<br />

eines Elementes. Einzelne Bausteine sollten weitgehend unabhängig<br />

voneinander arbeiten und über möglichst wenig Wissen<br />

der anderen Bausteine verfügen müssen. Die Kopplung hängt<br />

von der Anzahl und der Art der Verbindungen zu anderen Elementen<br />

ab. Die Anzahl externer Referenzen, die Reihenfolge von<br />

Aufrufen sowie technologische Aspekte beeinflussen die Kopplungsintensität.<br />

Eine lose Kopplung sorgt dafür, dass die einzelnen<br />

Bausteine weitgehend – sowohl in inhaltlicher wie zeitlicher<br />

Hinsicht – voneinander unabhängig funktionieren.<br />

hohe Kohäsion<br />

Die Kohäsion gibt an, wie sehr die Elemente eines Bausteins inhaltlich<br />

zusammengehören. Inhaltlich bedeutet, dass alle Elemente<br />

demselben Zweck dienen und damit der Baustein eine<br />

klare Zuständigkeit hat. Für eine bestimmte Funktionalität sollte<br />

es deshalb genau einen einzigen Baustein geben.


8. dESIGNpATTERNS<br />

software engineering 53<br />

Komplexe Architekturen und Systeme lassen sich durch die Verwendung<br />

dieser standardisierten Patterns und Checklisten einfacher<br />

und vollständiger beschreiben.<br />

definition<br />

designpatterns sind standardisierte Lösungsschablonen<br />

für wiederkehrende entwurfsprobleme.<br />

Die «Gang of Four» um Erich Gamma und kurz darauf eine Autorengruppe<br />

um Frank Buschmann initiierten mit ihren etwas<br />

mehr als 20 Patterns eine Beschreibungssprache für den Softwareentwurf,<br />

indem sie bewährte Lösungsmuster klar benannten,<br />

kategorisierten und strukturiert beschrieben. Diese grundlegenden<br />

Entwurfspatterns lassen sich in die Gruppen Erzeugung,<br />

Struktur und Verhalten aufteilen. Die für die Architektur relevanten<br />

Patterns sind in der nachfolgenden Grafik rot gekennzeichnet<br />

(Abb. 13).


Abb. 13: KategorisierUng Von designPattern<br />

erzeugung Verhalten<br />

struktur<br />

instanzieren<br />

Prototype<br />

builder<br />

factory<br />

entkopplung<br />

bridge<br />

Layering<br />

Model-View-<br />

Controller<br />

Konverter<br />

adapter<br />

einmalig<br />

singleton<br />

eintrittspunkt<br />

facade<br />

Publish-subscribe<br />

Verwandlung<br />

Vermittler<br />

observer<br />

state<br />

delegation<br />

Mediator<br />

strategy<br />

Vererbung<br />

template<br />

erweiterung<br />

decorator<br />

Platzhalter<br />

Proxy<br />

Protokollant<br />

Memento<br />

ausführer<br />

Command<br />

traversieren<br />

Visitor<br />

iterator<br />

ganzes-/teil<br />

Composite<br />

software engineering 55<br />

Exemplarisch wird auf die drei Patterns «Layering», «Model-<br />

View-Controller» und «Facade» näher eingegangen.<br />

8.1 lAyERING<br />

Das Layering oder Schichtenmodell (Abb. 14) ist wohl das bekannteste<br />

und wichtigste Konzept der Architektur, ein Gesamtsystem<br />

in aufeinander aufbauende, logische Abschnitte zu zerlegen.<br />

Dabei kennt im Idealfall ein einzelner Abschnitt nur die<br />

darunterliegende Ebene.<br />

Abb. 14: das sChiChtenModeLL<br />

darstellung<br />

Vermittlung<br />

geschäftslogik<br />

Persistenz<br />

Präsentationsschicht<br />

applikationsschicht<br />

geschäftsschicht<br />

Listen<br />

infrastrukturschicht<br />

Kunde<br />

daCL<br />

Kunde<br />

Controller<br />

Kunde<br />

detail<br />

window<br />

adresse<br />

daCL<br />

name:<br />

adresse:<br />

X


In der Softwarearchitektur hat sich eine Unterteilung in drei<br />

bis vier Schichten etabliert. Auf der obersten Ebene befindet<br />

sich die Mensch-Maschine-Schnittstelle. Die Daten der darunterliegenden<br />

Schicht werden in der für den Anwender optimalen<br />

Weise präsentiert und Benutzereingaben als Steuerungsbefehle<br />

weitergeleitet. Die nächste Ebene, die Applikationsschicht,<br />

üb<strong>erni</strong>mmt die Koordination zwischen der<br />

verarbeitenden Geschäfts- und der darstellenden Präsentationsschicht.<br />

Die dritte Ebene beinhaltet die eigentliche Logik,<br />

unabhängig von der konkreten Interaktion mit dem Benutzer<br />

und der darunterliegenden Infrastrukturschicht.<br />

Wichtig ist, wie bereits bei den Architekturprinzipien aufgeführt,<br />

die inhaltliche Entkopplung der Ebenen. Die Daten der<br />

Präsentationsschicht sind nicht zwangsläufig dieselben wie die<br />

der Infrastrukturschicht. So sind beispielsweise die in der Datenbank<br />

abgelegten Kundendaten nicht identisch mit den im<br />

individuellen Ausgabemedium verwendeten und dargestellten<br />

Informationen.<br />

8.2 mOdEl-VIEW-cONTROllER<br />

MVC steht für Model-View-Controller und ist eines der ältesten<br />

und elementarsten Entwicklungspatterns, das in moderneren<br />

Varianten wie MVP, Supervising Controller und anderen weiterentwickelt<br />

wurde (Abb. 15). Das MVC-Pattern fordert, die Darstellung<br />

der Daten von der eigentlichen Geschäftslogik zu trennen.<br />

Das Model steht für die Geschäftslogik und deren Daten. Es<br />

software engineering 57<br />

stellt damit die eigentliche Funktionalität des Systems dar. Die<br />

View ist die Präsentationsschicht und verantwortlich für die Visualisierung<br />

der Daten.<br />

Abb. 15: ModeL-View-ControLLer<br />

1.3: daten zurückgeben<br />

:View :Model<br />

1.4: daten anzeigen<br />

1.1: gebe statistik<br />

:Controller<br />

1 aaa 56<br />

2 bbb 77<br />

3 Ccc 99<br />

4 ddd 00<br />

1.3: daten zurückgeben<br />

1.2: daten aufbereiten<br />

Der Controller schliesslich fungiert als Mediator zwischen den<br />

beiden, indem er die durch den Bediener ausgelösten Aufträge<br />

interpretiert und gegebenenfalls an das Model weiterleitet sowie<br />

die erhaltenen Daten für die weitere Darstellung aufbereitet.


8.3 FAcAdE<br />

Abb. 16: faCade<br />

<br />

businesslogik<br />

facade<br />

Das Fassadenpattern (Facade) liefert eine uniforme Schnittstelle<br />

zu unterschiedlichen Komponenten oder Klassen eines Subsystems<br />

(Abb. 16). Es abstrahiert die Bestandteile eines grösseren<br />

Ganzen und definiert eine einheitliche Nutzung für eine Reihe<br />

unterschiedlicher Elemente. Im Gegensatz zur Bridge fasst eine<br />

Fassade die Arbeit mehrerer autonomer Objekte zusammen. So<br />

wird eine eingehende Aufgabe in der Regel auf mehrere Objekte<br />

dieses Subsystems verteilt.<br />

Service-orientierte Architekturkonzepte sind typische Beispiele<br />

für solche Fassaden. Dabei wird die Bedienung eines Service<br />

software engineering 59<br />

durch eine Vielzahl unterschiedlicher Helfer realisiert, die durch<br />

eine zentrale Klasse orchestriert werden. In Kombination mit<br />

dem zuvor besprochenen Schichtenmodell ist die Fassade ein<br />

wichtiges Instrument zur Beherrschung der stetig zunehmenden<br />

Komplexität.


9. ImplEmENTATION<br />

software engineering 61<br />

Das Ziel all der vorangegangenen Tätigkeiten war und ist die<br />

Implementation eines Stücks Code, das in seiner Funktion den<br />

Anforderungen und Erwartungen der Auftraggeber entspricht.<br />

Dieses Stück Code wird nach seiner erstmaligen Einführung vielen<br />

Veränderungen, Erweiterungen und Migrationen unterzogen<br />

werden. Es ist deshalb wichtig, Clean Code zu schreiben.<br />

Clean Code ist einfach und strukturiert. Der Fokus ist dabei auf<br />

die spätere Weiterentwicklung gerichtet.<br />

hinweis<br />

dinge so einfach wie möglich gestalten, jedoch nicht einfacher<br />

(frei nach Albert Einstein).<br />

die foLgende aUfzähLUng fasst die wiChtigsten MerK-<br />

MaLe soLCher Codes zUsaMMen:<br />

• Sinnvolle Namen: Die Namen von Klassen, Datenstrukturen,<br />

Methoden und Attributen sind sorgfältig zu wählen.<br />

Sie sollten etwas über den Zweck und die Funktion, jedoch<br />

nichts über die technische Implementation aussagen.<br />

Funktionen sind Verben und die Klassen die Nomen.<br />

• Einfache Funktionen: Jede Funktion sollte nur gerade einen<br />

Arbeitsschritt ausführen, der im Namen klar ausgedrückt<br />

wird.


• Kommentar: Ziel des Kommentars ist es, die eigenen Gedan-<br />

ken, die zum nachfolgenden Code geführt haben, niederzuschreiben.<br />

Der Kommentar sollte nicht wiederholen, was im<br />

Code offensichtlich ist.<br />

• Formatierung: Eine saubere Formatierung erleichtert das Lesen.<br />

Eine klare Struktur und eine einheitliche Darstellung lassen<br />

auf einen besonnen und strukturiert denkenden Entwickler<br />

schliessen. Welche Formatierung gewählt wird, ist<br />

nicht entscheidend; entscheidend ist, dass diese konsistent<br />

angewendet wird.<br />

• Fehlerbehandlung: Clean Code ist robust und reagiert auf<br />

Unvorhergesehenes zweckmässig. Bei jedem Statement ist zu<br />

bedenken, was schiefgehen könnte, um darauf entsprechend<br />

zu reagieren. Es ist keine Sache, einen Code zu schreiben, es<br />

ist aber eine Meisterschaft, einen zuverlässigen Code zu<br />

schreiben!<br />

• Systemgrenzen: Der Einsatz von Komponenten von<br />

Drittherstellern und die Kommunikationspfade zu den Umsystemen<br />

sind mit Bedacht zu wählen und durch entsprechende<br />

Klassen zu kapseln. Drittsysteme haben die Gewohnheit,<br />

sich zu verändern und sich nicht immer so zu verhalten,<br />

wie erwartet!<br />

• Klassen: Auch wenn nicht objektorientiert entwickelt wird,<br />

ist in Klassen zu denken. Dinge, die zusammengehören, sollten<br />

zusammen sein und damit die darunterliegenden Daten<br />

verbergen (Information Hiding).<br />

• Concurrency: Gleichzeitigkeit ist allgegenwärtig und schwer<br />

kontrollierbar. Da das zeitliche Verhalten im Zielsystem unbekannt<br />

ist, muss der Zugriff auf gemeinsame Daten allein<br />

software engineering 63<br />

durch den Code gesichert sein. Gleichzeitigkeit kann nur ansatzweise<br />

getestet werden, weshalb dem Design eine wichtige<br />

Rolle zukommt.<br />

• Nicht auf Vorrat programmieren: Es ist zu vermeiden, eine<br />

Klasse um Operationen zu erweitern, die vielleicht irgendwann<br />

in Zukunft nützlich sein könnten. Jeder Code – auch<br />

ein toter – muss gewartet werden.<br />

9.1 REFAcTORING<br />

Nicht nur Codierungsrichtlinien und eine zweckmässige Entwicklungsumgebung<br />

helfen, die Qualität des Codes zu verbessern.<br />

Zentrale Methoden zur Sicherstellung guter Codequalität<br />

sind das Refactoring und in direkter Abhängigkeit das Unit-Testing,<br />

ohne das ein Refactoring nicht möglich wäre. Da es in der<br />

Softwareentwicklung kaum möglich ist, ein komplexes System<br />

auf Anhieb richtig zu entwerfen, ist der Code während der Entwicklung<br />

ständig zu verbessern.<br />

Fowler und Beck haben diese Tätigkeit Refactoring genannt. Es<br />

ist die stetige Bereinigung der internen Struktur einer Software<br />

ohne sichtbare Verhaltensänderung. Dabei wird der Quellcode<br />

kontinuierlich überarbeitet, um ihn lesbarer und einfacher änderbar<br />

zu machen. Doppelter oder nicht mehr benötigter Code<br />

wird eliminiert, separate Methoden zu selbständigen Klassen<br />

werden zusammengeführt, Namen sinnvoller gewählt und Datenstrukturen<br />

ständig verbessert.


wiChtig zU wissen<br />

stetige Verbesserung und überarbeitung ist ein fixer bestandteil<br />

jeder Programmierung.<br />

Ohne kontinuierliches Refactoring degradiert eine Software zur<br />

Unleserlichkeit, und jede weitere Änderung wird zu einem nicht<br />

abschätzbaren Risiko. Der Aufwand für das Refactoring ist unbedingt<br />

in die tägliche Arbeit einzuplanen. Bei jeder Änderung des<br />

Codes oder bei sichtbaren Anzeichen von schlechtem Programmierstil<br />

ist der Code auf Verbesserungspotenzial zu prüfen und<br />

zu überarbeiten.<br />

9.2 uNIT-TESTS<br />

Unit-Tests stellen sicher, dass mit dem Refactoring die eigentliche<br />

Funktionalität nicht verändert wurde. Unit-Tests sind Codefragmente,<br />

die der Entwickler selbst geschrieben hat, um das<br />

Verhalten einer Klasse zu prüfen. Durch Unit-Tests lassen sich<br />

Zeit und Kosten einsparen sowie die Qualität erhöhen. Unerwünschtes<br />

Verhalten nach einer Codeänderung oder einem Refactoring<br />

wird unmittelbar sichtbar gemacht. Dies vereinfacht<br />

eine frühzeitige Fehlerkorrektur und macht das System zuverlässiger.<br />

Durch die konsequente Definition der möglichen Testpfade<br />

lassen sich gleichzeitig Mängel an den Anforderungen oder<br />

software engineering 65<br />

am Design feststellen. Obwohl der Initialaufwand bei der Anwendung<br />

von standardisierten Unit-Tests etwas höher ist, können<br />

dadurch die bei den Integrations- und Systemtests identifizierten<br />

Fehler leichter behoben werden. Die Granularität von<br />

Unit-Tests und welche Fälle, Klassen und Methoden zu testen<br />

sind, muss in der Anfangsphase festgelegt werden. Ein praktikabler<br />

Weg ist, sich auf die Hauptklassen oder diejenigen Komponenten<br />

zu beschränken, die zur grundsätzlichen Funktionalität<br />

beitragen oder kritisch für das Verhalten des Systems sind.<br />

Eine weitere nicht zu unterschätzende Herausforderung ist zudem<br />

die Wartung der Unit-Tests. Unit-Tests sind, wie der eigentliche<br />

Code auch, zu verwalten und ständig weiterzuentwickeln,<br />

um einen positiven Gesamtnutzen zu erhalten.


Abb. 17: diagraMMe iM ProzessabLaUf<br />

anforderung<br />

analyse<br />

design<br />

implementation<br />

systemkontext anwendungsfälle<br />

Logische architektur<br />

designklassen<br />

Verteilung<br />

geschäftsklassen<br />

businessobjekte<br />

sequenz<br />

aktivität<br />

Name: Einchecken<br />

Kurzbeschreibung:<br />

Starten einer neuen Reise am Touch-Point<br />

Primären Akteur: Reisende<br />

Vorbedingung:<br />

Reisende hat gültiges Konto<br />

Basisablauf:<br />

1. Kunde bewegt Handy an den Touch-Point<br />

2. System signalisiert dem Handy die Erkennung<br />

3. Handy fodert Reisende auf Check-In zu bestätigen<br />

4. System eröffnete Reise<br />

5. Handy zeigt erfolgreiche Eröffnung an<br />

Nachbedingung:<br />

Reise ist eröffnet<br />

Komponenten<br />

sequenz<br />

db-Modell<br />

software engineering 67


software engineering 69<br />

10. mEThOdEN FüR dIE umSETzuNG<br />

In einem Projekt werden Informationen in Disziplinen bearbeitet,<br />

konkretisiert und den nachfolgenden Disziplinen übergeben.<br />

Für einen reibungslosen Informationsfluss zwischen Disziplinen<br />

und Personen in einem Projekt hat es sich bewährt, interdisziplinäre<br />

Teams zu formen und mittels Reviews, Workshops<br />

oder anderer Methoden die Informationen weiterzugeben. Die<br />

vorangehende Abbildung (Abb. 17) illustriert in vereinfachter<br />

Form am Beispiel von UML-Diagrammen, welche Teilergebnisse<br />

die verschiedenen Disziplinen produzieren und anderen zur Verfügung<br />

stellen.<br />

beisPieLe für Methoden, die in den disziPLinen oder deren<br />

übergängen angewandt werden Können:<br />

• Anforderung: Requirements Engineering (siehe ERNI<br />

Essential «Requirements Engineering»), Priorisierung<br />

• Analyse: Class Responsibility and Collaboration (CRC)<br />

Cards, Use Case Realisation Workshop, Heuristiken<br />

• Design: Domain-Driven Design (DDD), Model-Driven<br />

Design (MDD)<br />

• Implementation: Test-Driven Design (TDD), Refactoring,<br />

Unit-Tests<br />

Beim oben genannten Vorgehen ist es wichtig, die Anforderungen<br />

zu priorisieren.


PriorisierUng<br />

Ziele der Priorisierung sind das frühzeitige Eliminieren von tech-<br />

nischen Risiken und die rasche Bereitstellung der wichtigsten<br />

Funktionen. Hierzu werden Anforderungen (Use Cases, Featurelisten<br />

u.a.) während der Analyse durch den Architekten und die<br />

Vertreter des Geschäfts priorisiert. Die Priorisierung untersucht<br />

dabei die Relevanz des Anwendungsfalls in Bezug auf das Geschäft<br />

und die Architektur und ordnet dies in einer zweidimensionalen<br />

Matrix. Basierend auf dieser Matrix werden die Anforderungen,<br />

beginnend mit den höchstpriorisierten, auf die Projektiterationen<br />

verteilt und implementiert.<br />

Use Case reaLisation worKshoP<br />

Die Nutzen von Use Case Realisation Workshops sind die vollständige<br />

Beschreibung von Abläufen und Datenobjekten sowie<br />

ein gemeinsames Verständnis über die Disziplinengrenzen hinweg.<br />

Durch die sukzessive Abbildung der Use Cases in Interaktionsdiagrammen<br />

und im Domain Object Model entstehen das Design<br />

Model und ein Architekturkandidat. Die Use Cases bilden<br />

dabei die Basis der Use Case Realisation Workshops, in denen<br />

geeignete Experten und Projekt-Stakeholder die Interaktionen<br />

zwischen den Aktoren und dem zu entwickelnden System gemeinsam<br />

beschreiben. Jeder Workshop behandelt dabei ein spezifisches<br />

Thema, das sogenannte Use Case Realisation Package.<br />

Daraus lassen sich die Systemgrenze sowie die architekturrelevanten<br />

Schnittstellen definieren. Für jeden realisierten Use Case<br />

muss mindestens ein Interaktionsdiagramm erstellt werden. Ak-<br />

software engineering 71<br />

tivitäts- und Zustandsdiagramme sowie das Domain Object Model<br />

ergänzen das Design Model. Die Erkenntnisse aus den Workshops<br />

müssen zeitnah konsolidiert und in der Architekturdokumentation<br />

festgehalten werden.<br />

CrC-Karten<br />

Die Methode der CRC-Karten ist ein unkompliziertes und effektives<br />

Mittel, auf spielerische Art Klassen zu finden und deren<br />

Beziehungen untereinander aufzuzeigen (Abb. 18). CRC steht für<br />

Class Responsibility and Collaboration, übersetzt Klassenzuständigkeit<br />

und -zusammenarbeit.<br />

Dabei wird auf der Vorderseite einer postkartengrossen Karte der<br />

Zweck einer Klasse als Kurzbeschreibung aufgeführt, und auf der<br />

Rückseite werden ihre Zuständigkeit sowie ihre Verbindungen<br />

zu anderen Klassen beschrieben. Unterhalb der Beschreibung<br />

der Klasse auf der Vorderseite wird ein allfällig angewandtes Entwurfspattern<br />

erwähnt. Die Zuständigkeit auf der Rückseite sind<br />

Operationen und Attribute, die dokumentieren, was eine Klasse<br />

tut und was sie weiss.


Abb. 18: aUfteiLUng der CrC-Karten<br />

Vorderseite<br />

name der Klasse superklasse zuständigkeit zusammenarbeit<br />

Kurzbeschreibung<br />

der Klasse, übersicht über<br />

aufgaben der Klasse<br />

anzuwendende Muster<br />

rückseite<br />

operationen<br />

attribute<br />

andere Klassen<br />

Da die Methode nicht an ein spezifisches Werkzeug auf dem<br />

Computer gebunden ist und ihre Anwendung innerhalb weniger<br />

Minuten erklärt werden kann, eignet sie sich hervorragend<br />

dazu, innerhalb eines Workshops gemeinsam ein initiales Klassenmodell<br />

zu entwerfen. In einem ersten Schritt werden mögliche<br />

Kandidaten gesammelt, ohne diese zu bewerten. Erst in einem<br />

zweiten Schritt werden die Vorschläge geprüft und das<br />

Klassendesign konsolidiert. Dazu werden technologiespezifische<br />

Klassen eliminiert und Doppelnennungen zusammengeführt.<br />

Sodann lassen sich die Karten auf Packpapier festmachen und<br />

ihre Interaktionspfade oder statischen Beziehungen einzeichnen.<br />

software engineering 73


11. bEGRIFFE/GlOSSAR<br />

deutsch (inkl.<br />

Anglizismen)<br />

software engineering 75<br />

Englisch bedeutung in diesem dokument<br />

anwendungsfall Use Case Modellelement einer Modellierungssprache<br />

für software und andere<br />

systeme: die anwendungsfall-beschreibung<br />

ist eine semiformale notation,<br />

um grobe anwenderforderungen zu<br />

dokumentieren.<br />

architekturansatz architectural<br />

approach<br />

elementare architekturstrukturen wie<br />

Patterns, styles, Kommunikationsprotokolle<br />

usw.<br />

artefakt artifact Produzierte daten oder dokumente<br />

(z.B. durch ein System).<br />

ataM ataM architecture trade-off analysis Method:<br />

weitverbreitete Methode zur architekturbewertung.<br />

domäne domain fach- bzw. geschäftsbereich, in dem<br />

das system eingesetzt wird.<br />

geschäftsobjekte business objects geschäftsobjekte repräsentieren reale<br />

objekte der geschäftlichen welt innerhalb<br />

von informationssystemen.<br />

interessenvertreter stakeholder Jemand, der direkt oder indirekt einfluss<br />

auf anforderungen hat. beispiele: der<br />

endnutzer, der Ceo der auftraggeberfirma,<br />

der gesetzgeber.


deutsch (inkl.<br />

Anglizismen)<br />

Komponente<br />

oder baustein<br />

Englisch bedeutung in diesem dokument<br />

Component Klar abgrenzbarer bestandteil innerhalb<br />

eines systems. eine Komponente<br />

kann sich in der software<br />

verschiedenartig manifestieren,<br />

z.b. als Codepaket, als Codebibliothek<br />

oder als eigenständige<br />

applikation.<br />

Kompromiss trade-off ataM-begriff: eine architektureigenschaft,<br />

die mehrere Qualitätsmerkmale<br />

berücksichtigt.<br />

Muster Pattern ein Muster beschreibt ganz allgemein<br />

eine bewährte Lösung zu einem<br />

bestimmten Problem. Muster<br />

wurden in der softwareentwicklung<br />

populär durch designpatterns<br />

beschrieben und werden heute<br />

in verschiedensten disziplinen<br />

eingesetzt.<br />

Qualitätsbaum Utility tree hierarchische repräsentation von<br />

wichtigen attributsspezifischen<br />

anforderungen, in denen die Knoten<br />

Qualitätsziele und die blätter<br />

szenarien darstellen.<br />

risiko risk ataM-begriff: eine architektureigenschaft,<br />

die im widerspruch<br />

zu Qualitätsmerkmalen steht.<br />

deutsch (inkl.<br />

Anglizismen)<br />

software engineering 77<br />

Englisch bedeutung in diesem dokument<br />

schnittstelle interface definierter übergang zwischen zwei<br />

abgrenzbaren einheiten. schnittstellen<br />

bestehen auf allen ebenen, zwischen<br />

systemen, Komponenten oder Klassen.<br />

sensibler Punkt sensitivity Point ataM-begriff: eine architektureigenschaft,<br />

die bei kleinen änderungen zu<br />

einem risiko werden kann.<br />

UML UML Unified Modeling Language: standardisierte<br />

sprache zur Modellierung von<br />

software und systemen.<br />

Umsetzung implementation Codierung der im design festgelegten<br />

Klassen und Methoden. hier wird die<br />

eigentliche software «produziert».


12. REFERENzEN<br />

arLow, JiM Und iLa neUstadt.<br />

UML 2 and the Unified Process.<br />

Addison Wesley, 2005.<br />

bass, Len, PaUL CLeMents Und riCK KazMan.<br />

Software Architecture in Practice.<br />

Addison-Wesley, 2003.<br />

software engineering 79<br />

ben-ari, M.<br />

Principles of Concurrent and Distributed Programming.<br />

Addison-Wesley, 2006.<br />

booCh, grady.<br />

Object-Oriented Analysis and Design with Applications.<br />

Addison-Wesley, 2007.<br />

eeLes, Peter Und Peter CriPPs.<br />

Process of Software Architecting.<br />

Addison-Wesley, 2009.<br />

erL, thoMas.<br />

Service-Oriented Architecture: Concepts, Technology, and Design.<br />

Prentice Hall, 2005.<br />

ford, neaL.<br />

Productive Programmer.<br />

O›Reilly, 2008.


fowLer, Martin Und Kent beCK.<br />

Refactoring: Improving the Design of Existing Code.<br />

Addison-Wesley, 1999.<br />

gaMMa, eriC, et aL.<br />

Design Pattern.<br />

Addison-Wesley, 1995.<br />

LanKhorst, MarC.<br />

Enterprise Architecture at Work.<br />

Springer, 2005.<br />

LarMan, Craig.<br />

Applying UML and Patterns.<br />

Prentice Hall, 2005.<br />

Martin, robert C. CLean Code:<br />

A Handbook of Agile Software Craftsmanship.<br />

Prentice Hall, 2008.<br />

reeKie, John Und rohan MCadaM.<br />

Software Architecture Primer.<br />

Angophora, 2006.<br />

rozansKi, niCK Und eoin woods.<br />

Software Systems Architecture: Working with Stakeholders<br />

Using Viewpoints and Perspectives.<br />

Addison-Wesley, 2005.<br />

sPineLLis, dioMidis Und georgios goUsios.<br />

Beautiful Architecture.<br />

O’Reilly, 2009.<br />

starKe, gernot.<br />

Effektive Software-Architekturen.<br />

Hanser, 2008.<br />

VogeL, oLiVer.<br />

Software Architektur.<br />

Spektrum, 2009.<br />

software engineering 81<br />

wirfs-broCK, rebeCCa Und aLan MCKean.<br />

Object Design: Roles, Responsibilities, and Collaborations.<br />

Addison-Wesley, 2002.


diagraMMe iM ProzessVerLaUf<br />

anforderung<br />

analyse<br />

design<br />

implementation<br />

systemkontext anwendungsfälle<br />

Logische architektur<br />

designklassen<br />

Verteilung<br />

geschäftsklassen<br />

businessobjekte<br />

sequenz<br />

aktivität<br />

Name: Einchecken<br />

Kurzbeschreibung:<br />

Starten einer neuen Reise am Touch-Point<br />

Primären Akteur: Reisende<br />

Vorbedingung:<br />

Reisende hat gültiges Konto<br />

Basisablauf:<br />

1. Kunde bewegt Handy an den Touch-Point<br />

2. System signalisiert dem Handy die Erkennung<br />

3. Handy fodert Reisende auf Check-In zu bestätigen<br />

4. System eröffnete Reise<br />

5. Handy zeigt erfolgreiche Eröffnung an<br />

Nachbedingung:<br />

Reise ist eröffnet<br />

Komponenten<br />

sequenz<br />

db-Modell<br />

abLaUf arChiteKtUrentwUrf<br />

Cartoon<br />

software requirements<br />

specification<br />

architekturdokument<br />

aktivitäten<br />

artefakte<br />

referenzen<br />

1.<br />

2.<br />

3.<br />

4.<br />

5.<br />

6.<br />

7.<br />

8.<br />

9.<br />

akzeptiert<br />

stakeholder<br />

identifizieren<br />

interessen<br />

erfassen<br />

Kontext<br />

definieren<br />

input<br />

konsolidieren<br />

szenarien<br />

identifizieren<br />

best Practices<br />

und Vorgaben<br />

identifizieren<br />

architekturkandidaten<br />

entwerfen<br />

architekturoptionen<br />

evaluieren<br />

architektur<br />

bewerten<br />

software engineering 83<br />

nicht akzeptiert<br />

Vision<br />

rahmenbedingungen<br />

referenzarchitektur<br />

architekturpatterns<br />

andere Projekte<br />

architektur<br />

10.<br />

überarbeiten


enables & delivers<br />

www.<strong>erni</strong>-<strong>consultants</strong>.<strong>com</strong>

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!