This document discusses fundamental concepts of software architecture, including: - Breaking systems down into modular components through techniques like encapsulation, contracts, and decoupling. - Scaling systems up through parametrization, simplicity, decentralization, and standard libraries. - Conceptualizing at a higher level of abstraction using techniques like abstraction, hierarchical decomposition, specialization, formalization, and viewpoints. - Best practices like making dependencies and transformations explicit, limiting freedom to avoid side effects, and testing semantics rather than syntax.

1. Fundamentalsof Software Architecture Lookingbeyondthehype MarkusVölter (voelter@acm.org)

2. 1 Introduction

3. Frustratedbyall thehype? Frustrated by all the hype?

4. If sothispresentationisforyou.

5. Otherwiseyoushouldleave

6. People oftentalk abouttechnologiesinsteadofarchitecturalconcepts.

7. Technology-discussionscreate a lotofaccidentalcomplexity.

8. Architecturalessenceishiddenbehindtechgobbledygook

9. Conceptschangemuch More slowlythanthe Hype-driventechno marketing

10. Thispresentation: Thispresentation: Timeless concepts

11. Thispresentation: Thispresentation: Relationships betweenthem

12. Thispresentation: Thispresentation: Exampleslanguages architecture technology

13. awarenesswhenbuildingsystems Goals

14. checklistsforreviewingsystems Goals

15. educationofdevelopersandarchitects Goals

16. ConceptsAtomicCombinable Technology NeutralDescribableNamed (Patterns, Laws, Principles)

17. CombinatorsB ! A B  A BA

18. Ok, let‘sgo… Ok, let‘sgo…

19. 2 Breaking Things Down

20. Modularize Procedures, Classes, Components, Services, User Stories

21. ! Modularize Encapsulate Private Members Frameworks Facade Pattern Components Layers/Rings/Levels Packed Data Wrapper

22. ! Modularize Contracts Interfaces Pre/Post Conditions Protocol State Machines Message Exchange Patterns Published APIs

23. Decoupling CompensatingTx Message Queues ! Modularization

24.  Modularize Handle Crosscuts Aspect Orientation Interceptors Application Servers Exception Handling

25. Go Down Encapsulate ! Modularize Assembler in C C in Python/Ruby SQL in Java

26. Isolate Pure functional vs. Impure Safety Critical Parts Real-Time Kernel OS Processes ! Modularize

27. IsolateTechnology ! Modularize Isolate POJOs HALs JBI/SCA Code Gen/MDSD

28. 3 Scalingthingsup

29. Parametrization Function Arguments Command-Line Args Configuration Files ! Modularization

30. Simplicity Web Lisp XML

31. Decentralization ! Contracts EmergentBehaviour The Internet Service-OrientedArchitecture

32. Bootstrapping Languages Compilers IDEs

33. Standard Library Lisp (Grow A Language) AutosarSysComponentsMicrokernel OSs ! Modularize ! Types & Instances

34. Orthogonality Closures, Program As Data, Macros, Higher-Order Functions

35. Identity Pointers GUIDs MAC-Address URI QualifiedNames

36. 4 Conceptualization

37. Abstraction Operating Systems High-Level Languages Models, DSLs

38. Types & Instances ProgrammingLanguages Components Models & Metamodels RDBMS/XML Schemas

39. Hierarchical Decomposition  Modularize Procedures/Methods State Machines, Components

40. Specialize Currying Inheritance State Machines

41. ! Abstraction Formalize Languages Contracts Models State Machines

42. Viewpoints ! Formalization Configuration Files 4+1 Model Blackbox/Whitebox Types/Instances/Deployment

43. ! Formalization Notation UML Lisp Java Ruby

44. ! Modularize Go Meta Translators, Reflection, Meta Programming, AOP

45. Reflection ! Go Meta Languages (Lisp, Smalltalk, Ruby) Embedded Systems (Static)

46. ! Formalization ! Go Meta Translate Compilers, Transformers, Generators, Macros (Lisp, Converge)

47. ! Formalization ! Go Meta Formalize Interpret Business Process Engines Data Driven Systems (Dynamic) Languages

48. Tracking Impurity in Haskell: io(…) Tainting (Static Analysis) Session State ACT Pattern

49. Automate Build, Test, Translate ! Formalization

50. 5 DosandDon‘ts

51. ! Formalization Protocols Transctions Locking/Synchronization Resource Access

52. Make Explicit DOC Middleware Orthogonal Persistence (OR Mappers) DOC Middleware Orthogonal Persistence (OR Mappers) Make Transparent

53. Make Transparent Make Explicit Dependencies SOA, Messaging FunctionalProgramming PLE Variabilities Persistence: Loading Data

54. Software Architecture DSL: expressiveness MDSD: skeletons Scade/SystemC LimitFreedom

55. ! Formalization ! Go Meta Declaration Implementation App Servers (EJB), Plugin RT (Eclipse) Models, TransaactionalMemory

56. Test semantics, not syntax (code gen) Higher Order Functions (map, foreach) Transactional Memory Don‘t Overspecify

57.  Limit Freedom AvoidSideeffects FunctionalProgramming Concurrency (Sharing) Distribution

58. 6 Process

59. Iterate Algorithms Refactoring Agile Processes

60. Capture Best Practices Patterns, DSLs, Models, Translators

61. More I Ownership vs. Reference BuildLanguages CohesionandCoupling (do onethingright, composability) Indirection (polymorphism, memreferencesforcompaction, namingservice) Prevention vs. Compensation

62. More II BuildPlatforms Versioning Pessimistic/Optimistic/Compensating Localize (Sync in MP, UML-M2M) Container (AppServer) Lazy/On-demand, Eager SelfModification (MetaProg, MOPs, Embedded Optimization Measure: metrics, performance tuning, scalability, test coverage

63. What do youthink? More Fundamentals? More Examples? Pleaseletmeknow! voelter@acm.org

64. THE END. THE END.