Dit is mijn samenvatting van het vak Software architectuur, gegeven door professor Mannaert aan de Universiteit van Antwerpen. Mijn samenvatting bevat de geziene leerstof, de gegeven gastcolleges, de reflectie op het groepswerk en de gekregen examenvragen van 2021. Het is in het Engels geschreven, ...
0. Contents
0. Contents .......................................................................................................................................... 1
1. Introduction: The Need for Design Science in Software Architecture ............................................ 5
1.1. Wat is een software architect? ............................................................................................... 5
1.2. Concepts related to software architecture ............................................................................. 5
1.2.1. Science and engineering .................................................................................................. 5
1.2.2. On “Design Science” ........................................................................................................ 6
1.2.3. The Science of Design: time to build .............................................................................. 6
1.2.4. On Software Architecture................................................................................................ 6
1.3. Software architecture and need for traceability ..................................................................... 7
1.4. Nabespreking gastsprekers ..................................................................................................... 7
1.4.1. Pieter Dubois: XPLUS ....................................................................................................... 7
1.4.2. Peter Van Bellingen: Colruyt ........................................................................................... 8
1.5. Issues with IS Methodologies & Software Architecture .......................................................... 9
1.6. IS Methodologies ..................................................................................................................... 9
1.6.1. Scientific literature ........................................................................................................ 10
1.6.2. Which Methodologies ? ................................................................................................ 10
1.6.3. Authors of Methodologies ............................................................................................ 10
1.6.4. Advantages of Methodologies ...................................................................................... 10
1.6.5. Issue 1 – Adoption ......................................................................................................... 10
1.6.6. Issue 2 – Vagueness ....................................................................................................... 11
1.6.7. Issue 3 – Systematics ..................................................................................................... 11
1.6.8. Issue 4 - Traceability ...................................................................................................... 11
1.6.9. The Law of Increasing complexity: Manny Lehman ...................................................... 12
1.6.10. Crucial issues for software architecture ........................................................................ 12
2. NST Foundation Lecture 1: The Design Cycle as a Dynamic System ............................................. 12
2.1. Dynamic instability due to positive feedback ....................................................................... 13
2.2. From Stable Operations to Evolvable Designs ...................................................................... 13
2.3. Change Ripples: A Basic Transformation ............................................................................... 14
2.4. Ripple Effects in a Growing Modular Structure ..................................................................... 14
2.5. Design Theorems for Stable Software ................................................................................... 14
3. NST Foundation Lecture 2: Design Theorems for Software Stability ............................................ 15
3.1. Separation of Concerns – Reductio ad Absurdum ............................................................... 15
3.1.1. Solution: Separation of concerns .................................................................................. 15
3.1.2. Manifestations............................................................................................................... 16
3.1.3. Coding implications ....................................................................................................... 16
3.2. Action Version Transparency – Reductio ad Absurdum ........................................................ 16
3.2.1. The solution ................................................................................................................... 17
3.2.2. Manifestations............................................................................................................... 17
, 3.2.3. Coding implications ....................................................................................................... 17
3.2.4. Separate emerging concern .......................................................................................... 17
3.3. Data Version Transparency – reductio ad absurdum ............................................................ 18
3.3.1. Solution.......................................................................................................................... 18
3.3.2. Manifestations............................................................................................................... 18
3.3.3. Coding implications ....................................................................................................... 18
3.4. Separation of states............................................................................................................... 18
3.4.1. How to solve this? ........................................................................................................ 19
3.4.2. Manifestations............................................................................................................... 19
3.4.3. Coding implications ....................................................................................................... 19
3.4.4. Dangerous of synchronous object pipelines, thus use stateful workflow systems....... 19
3.4.5. Async Processing ........................................................................................................... 20
3.5. Design Theorems Interpreted ............................................................................................... 20
3.6. Coupling and Cohesion Revisited .......................................................................................... 20
3.7. Coupling and Cohesion Reinterpreted .................................................................................. 21
4. NST Foundation Lecture 3: Software Element Structures ............................................................ 21
1.1. Design theorems for stable software .................................................................................... 21
4.1. Encapsulating Basic Primitives .............................................................................................. 22
4.2. Separating Cross-cutting concerns ........................................................................................ 22
4.3. The emergence of Elements .................................................................................................. 23
4.4. An advanced Transformation ................................................................................................ 24
4.5. Instability of Basic Transformation ........................................................................................ 24
4.6. An Advanced Transformation................................................................................................ 24
4.7. Normalized Systems Elements .............................................................................................. 25
4.8. Expansion of Elements .......................................................................................................... 25
4.9. A Construction Concept Element .......................................................................................... 25
5. NST Foundation Lecture 4: Expansion, Harvesting, and Rejuvenation ........................................ 25
5.1. Recap ..................................................................................................................................... 26
5.2. On Updating Recurring Structure .......................................................................................... 27
5.2.1. Catch 22: The only way out ........................................................................................... 27
5.3. Expansion of Elements .......................................................................................................... 27
5.3.1. Expand Models to Codebase ......................................................................................... 28
5.3.2. Expand Templates to Codebase .................................................................................... 28
5.3.3. Third dimension: Connect Utilities to Codebase ........................................................... 28
5.3.4. A fourth dimension: Subjoin Craftings/custom code to Codebase ............................... 28
5.3.5. Re-generate and Inject Craftings ................................................................................... 29
5.3.6. Continuous Rejuvenation .............................................................................................. 29
5.4. Variability Dimensions and Expansion .................................................................................. 29
5.5. Deploying Elements in Layers ................................................................................................ 30
5.6. Packaging Elements in Archives ............................................................................................ 30
,6. NST Foundation Lecture 5: On Dimensions of Variability and Evolvability .................................. 31
6.1. Change Dimension 1: The Models/Mirrors ........................................................................... 32
6.1.1. Stable Changes 1: Mirrors – Data .................................................................................. 32
6.1.2. Stable Changes 1: Mirrors – Task .................................................................................. 32
6.1.3. Stable Changes 1: Mirrors – Flow .................................................................................. 33
6.2. Change Dimension 2: The Utilities ........................................................................................ 33
6.3. Change Dimension 3: The Skeletons ..................................................................................... 34
6.4. Change Dimension 4: The Craftings ...................................................................................... 34
7. NST Foundation Lecture 6: Realization of Meta-Circular Expansion............................................. 34
7.1. Automatic Programming ....................................................................................................... 34
7.2. The need for Automatic Programming.................................................................................. 35
7.3. The Field of Automatic Programming ................................................................................... 35
7.4. Relevance of Automatic Programming.................................................................................. 36
7.5. The Power of Circularity ........................................................................................................ 36
7.6. Meta-circularity in Software Engineering.............................................................................. 36
7.7. Why Meta-Circularity in Meta-Programming? ...................................................................... 37
7.7.1. Closing the Meta-Circle (phase 1) ................................................................................. 37
7.7.2. Closing the Meta-Circle (phase 2) ................................................................................. 37
7.7.3. Closing the Meta-Circle (phase 3) ................................................................................. 38
7.8. Need for Meta-Level Interfaces ............................................................................................ 39
7.9. Two-sided Meta-Level Interfaces .......................................................................................... 39
7.10. Closing the Meta-Circle: Expander API .............................................................................. 39
7.10.1. Expander API: Model/Mapping/Template .................................................................... 40
7.11. The Power of Circularity: Resonance ................................................................................ 40
8. NST Tutorial: From Element Structures to Implementation Classes ............................................. 40
8.1. The Emergence of Elements .................................................................................................. 41
8.2. An Advanced Transformation................................................................................................ 41
8.2.1. InvoiceDetails: Encapsulating Data Transfer ................................................................. 41
8.2.2. InvoiceData: Encapsulating JPA Code ............................................................................ 42
8.2.3. Multiple Concerns within a Concern ............................................................................. 42
8.2.4. Task entity: An Advanced Transformation .................................................................... 43
8.2.5. Deploying Elements across Multi-Tiers ......................................................................... 44
8.2.6. Packaging Element in Layered Archives ........................................................................ 44
9. Special topics: encapsulation of utility frameworks and integration layers ................................. 45
9.1. Encapsulating utilities through elements .............................................................................. 45
9.2. Deploying and Packaging Elements in Layers ........................................................................ 45
9.3. Data Element: Encapsulating Utilities ................................................................................... 45
9.4. Incoming integration ............................................................................................................. 46
9.5. Outgoing integration ............................................................................................................. 46
10. Chapter 16: IS Development and Analysis ................................................................................ 47
, 10.1. Recap: IS Methodologies ....................................................................................................... 47
10.2. Data Analysis Techniques ...................................................................................................... 47
10.2.1. EURent Data Model ....................................................................................................... 48
10.2.2. Flow Analysis Techniques .............................................................................................. 51
10.3. Integrated Analysis Models ................................................................................................... 53
10.4. The System Development Process ........................................................................................ 53
10.5. Reflections on Project Management ..................................................................................... 54
11. Gastcollege - Geert Haerens (ENGIE): Evolvable Software Architecture .................................. 54
11.1. Business logic Layer ............................................................................................................... 56
11.2. Use Cases ............................................................................................................................... 56
11.3. User interface – external technology .................................................................................... 56
11.4. User stories ............................................................................................................................ 56
11.5. Cross cutting concerns .......................................................................................................... 56
11.6. Agile & Architecture .............................................................................................................. 57
11.7. CONCLUSIE ............................................................................................................................ 58
12. Group assignment ..................................................................................................................... 59
12.1. Phase 1 Analysis: Issues ......................................................................................................... 59
12.2. Summary Metalessen ............................................................................................................ 59
12.3. Enkele andere niet-meta lessen ............................................................................................ 60
12.4. Examenvragen ....................................................................................................................... 61
Voordelen van het kopen van samenvattingen bij Stuvia op een rij:
√ Verzekerd van kwaliteit door reviews
Stuvia-klanten hebben meer dan 700.000 samenvattingen beoordeeld. Zo weet je zeker dat je de beste documenten koopt!
Snel en makkelijk kopen
Je betaalt supersnel en eenmalig met iDeal, Bancontact of creditcard voor de samenvatting. Zonder lidmaatschap.
Focus op de essentie
Samenvattingen worden geschreven voor en door anderen. Daarom zijn de samenvattingen altijd betrouwbaar en actueel. Zo kom je snel tot de kern!
Veelgestelde vragen
Wat krijg ik als ik dit document koop?
Je krijgt een PDF, die direct beschikbaar is na je aankoop. Het gekochte document is altijd, overal en oneindig toegankelijk via je profiel.
Tevredenheidsgarantie: hoe werkt dat?
Onze tevredenheidsgarantie zorgt ervoor dat je altijd een studiedocument vindt dat goed bij je past. Je vult een formulier in en onze klantenservice regelt de rest.
Van wie koop ik deze samenvatting?
Stuvia is een marktplaats, je koop dit document dus niet van ons, maar van verkoper audreyvanlierde. Stuvia faciliteert de betaling aan de verkoper.
Zit ik meteen vast aan een abonnement?
Nee, je koopt alleen deze samenvatting voor €8,39. Je zit daarna nergens aan vast.
