erni essentials SOFTWARE ENGINEERING - erni-consultants.com
erni essentials SOFTWARE ENGINEERING - erni-consultants.com
erni essentials SOFTWARE ENGINEERING - erni-consultants.com
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>