Frustrated by all the hype?

Transcription

1 Fundamentals of Software Architecture Looking beyond the hype Markus Völter

2 Introduction

3 Frustrated by all the hype?

4 If so this presentation is for you.

5 Otherwise you should leave

6 People often talk about technologies instead of architectural concepts.

7 Technology discussions create a lot of accidental complexity.

8 Architectural essence is hidden behind tech gobbledygook

9 Concepts change much More slowly than the Hype driven di techno marketing

10 This This presentation: presentation: Timeless concepts

11 This This presentation: presentation: Relationships between them

12 This This presentation: presentation: Examples languages architecture technology

13 Goals awareness when building systems

14 checklists for reviewing systems Goals

15 education of developers and architects Goals

16 Concepts Atomic Combinable Technology Neutral Describable Named (Patterns, Laws, Principles)

17 Combinators B! A B A B A

18 Ok,, let s go

19 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 Compensating Tx Message Queues! Modularization

24 Handle Modularize Crosscuts Aspect Orientation Interceptors Application Servers Exception Handling

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

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

27 Isolate Technology Is solat te! M Modu ulariz ze POJOs HALs JBI/SCA Code Gen/MDSD

28 Scaling things up

29 Parametrization Function Arguments Command Line Args Configuration Files! Modularization

30 Simplicity Web Lisp XML

31 Decentralization! Contracts The Internet Emergent Behaviour Service Oriented Architecture

32 Bootstrapping Languages Compilers IDEs

33 Standard d Library Lisp (Grow A Language) Autosar Sys Components Microkernel OSs! Modularize! Types & Instances

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

35 Identity Pointers GUIDs MAC Address URI Qualified Names

36 Conceptualization

37 Abstraction ti Operating Systems High Level Languages Models, DSLs

38 Types & Instances Programming Languages Components Models & Metamodels RDBMS/XML Schemas

39 Hierarchical Decomposition ii 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 41M 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 Dos and Don ts

51 ! Formalization Protocols Transctions Locking/Synchronization Resource Access

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

53 Make Transparent MakeExplicit i Dependencies SOA, Messaging Functional lprogramming PLE Variabilities Persistence: Loading Data

54 Software Architecture DSL: expressiveness MDSD: skeletons Scade/SystemC Limit Freedom

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

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

57 Avoid Limit Freedom Sideeffects Functional Programming Concurrency (h (Sharing) Distribution

58 Process

59 Iterate Algorithms Refactoring Agile Processes

60 Patterns, DSLs, Models, Translators

61 More I Ownership vs. Reference Build Languages Cohesion and Coupling (do one thing right, composability) Indirection (polymorphism, mem references for compaction, naming service) Prevention vs. Compensation

62 More II Build Platforms Versioning Pessimistic/Optimistic/Compensating Localize (Sync in MP, UML M2M) M2M) Container (AppServer) Lazy/On demand, Eager Self Modification (Meta Prog, MOPs, Embedded Optimization Measure: metrics,performance tuning,scalability, test coverage

63 What do you think? More Fundamentals? More Examples? Please let me know!

64 THE END.