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
Les avantages d'acheter des résumés chez Stuvia:
Qualité garantie par les avis des clients
Les clients de Stuvia ont évalués plus de 700 000 résumés. C'est comme ça que vous savez que vous achetez les meilleurs documents.
L’achat facile et rapide
Vous pouvez payer rapidement avec iDeal, carte de crédit ou Stuvia-crédit pour les résumés. Il n'y a pas d'adhésion nécessaire.
Focus sur l’essentiel
Vos camarades écrivent eux-mêmes les notes d’étude, c’est pourquoi les documents sont toujours fiables et à jour. Cela garantit que vous arrivez rapidement au coeur du matériel.
Foire aux questions
Qu'est-ce que j'obtiens en achetant ce document ?
Vous obtenez un PDF, disponible immédiatement après votre achat. Le document acheté est accessible à tout moment, n'importe où et indéfiniment via votre profil.
Garantie de remboursement : comment ça marche ?
Notre garantie de satisfaction garantit que vous trouverez toujours un document d'étude qui vous convient. Vous remplissez un formulaire et notre équipe du service client s'occupe du reste.
Auprès de qui est-ce que j'achète ce résumé ?
Stuvia est une place de marché. Alors, vous n'achetez donc pas ce document chez nous, mais auprès du vendeur audreyvanlierde. Stuvia facilite les paiements au vendeur.
Est-ce que j'aurai un abonnement?
Non, vous n'achetez ce résumé que pour €8,39. Vous n'êtes lié à rien après votre achat.
