Software Design

1. Software Design Topics in Architectural Design Material drawn from [Shaw96, Perry93] Modified by Ian Davis (c) Spiros Mancoridis

2. Software Architecture Topics • Terminology and Motivation • Intuition About Architecture: • Building Architecture • Hardware • Network (c) Spiros Mancoridis

3. Abstraction • One characterization of progress in software development has been the regular increase in abstraction levels: • I.e., the conceptual size of software designer's building blocks. • Resulted in ever more complex software. • Increased dependence on architecture. (c) Spiros Mancoridis

4. Abstraction (Cont’d) • Early 1950s: Software was written in machine language: • programmers placed instructions and data individually and explicitly in the computer's memory, • insertion of a new instruction in a program might require hand checking the entire program to update references to data and instructions. (c) Spiros Mancoridis

5. Abstraction (Cont’d) • Early 1950s: • Reuse involved saving subroutines on paper tape, and filing in drawers. • Subroutines were mechanically spliced into new paper tape programs when needed. • Commitees meet to discuss which subroutines were best to use in a given situation. (c) Spiros Mancoridis

6. Assemblers • Some Machine code programming problems were solved by adding a level of abstraction between the program and the machine: • Symbolic Assemblers: • Names used for operation codes and memory addresses. • Memory layout and update of references are automated. • Macro Processors: • Allow a single symbol to stand for a commonly used sequence of instructions. (c) Spiros Mancoridis

7. Assemblers • Early CPU’s had poor architectures. Different registers had different instruction sets, and could not be used interchangeably. • Intelligent assemblers hide some of these problems. • People started formulating rules about how registers could be used in subroutine calls, and how assember should be structured. (c) Spiros Mancoridis

8. Programming Languages • Late 1950s: The emerging of the first high-level programming languages. Well understood patterns are created from notations that are more like mathematics than machine code. • evaluation of arithmetic expressions, • procedure invocation, • loops and conditionals (c) Spiros Mancoridis

9. Programming Languages (Cont’d) • FORTRAN becomes the first widely used programming language. • Algol and its successors followed with higher-levels of abstraction for representing data (types). • No clear recognition for need to support complex structures, recursion, stack etc. • Clear division between code and data. (c) Spiros Mancoridis

10. Abstract Data Types • Late 1960s and 1970s: Programmers shared an intuition that good data structure design will ease the development of a program. • Programmers recognized the need for standards, but disagreed on whose standards should be used. (c) Spiros Mancoridis

11. Abstract Data Types • Intuition was converted into theories of modularization and information hiding. • Data and related code are encapsulated into modules. • Interfaces to modules are made explicit. • Type checking become the norm. (c) Spiros Mancoridis

12. Abstract Data Types (Cont’d) • Various programming languages (e.g., Modula, Ada, Euclid) • Module Interconnection Languages (e.g., MIL75, Intercol) • emerge with implementations of this theory. (c) Spiros Mancoridis

13. Software Architecture • As the size and complexity of software systems increases, the design problem goes beyond algorithms and data structures. • Designing and specifying the overall system structure (Software Architecture) emerges as a new kind of problem. (c) Spiros Mancoridis

14. Software Architecture Issues • Organization and global control structure, • protocols of communication, synchronization, and data access, • assignment of functionality to design elements, • physical distribution, • selection among design alternatives. (c) Spiros Mancoridis

15. State of Practice • There is not currently a well-defined terminology or notation to characterize architectural structures. • However, good software engineers make common use of architectural principles when designing complex software. • These principles represent rules of thumb or idiomatic patterns that have emerged informally over time. Others are more carefully documented as industry standards. (c) Spiros Mancoridis

16. Descriptions of Architectures • “Camelot is based on the client-server model and uses remote procedure calls both locally and remotely to provide communication among applications and servers.” • Client and server are multi-threaded. • ODBC is employed by all interfaces. (c) Spiros Mancoridis

17. Descriptions of Architectures (Cont’d) • “Abstraction layering and system decomposition provide the appearance of system uniformity to clients, yet allow Helix to accommodate a diversity of autonomous devices. The architecture encourages a client-server model for the structuring of applications.” (c) Spiros Mancoridis

18. Descriptions of Architectures (Cont’d) • “We have chosen a distributed, object-oriented approach to managing information.” (c) Spiros Mancoridis

19. Descriptions of Architectures (Cont’d) • “The easiest way to make a canonical sequential compiler into a concurrent compiler is to pipeline the execution of the compiler phases over a number of processors. A more effective way is to split the source code into many segments, which are concurrently processed through the various phases of compilation (by multiple compiler processes) before a final, merging pass recombines the object code into a single program.” (c) Spiros Mancoridis

20. Some Standard Architectures • ISO/OSI Reference Model is a layered network architecture. • X Window System is a distributed windowed user interface architecture based on event triggering and callbacks. • NIST/ECMA Reference Model is a generic software engineering environment architecture based on layered communication substrates. (c) Spiros Mancoridis

21. The “Toaster” Model (c) Spiros Mancoridis

22. Intuition About Architecture (c) Spiros Mancoridis

23. Intuition About Architecture • It is interesting that we have so few named software architectures. This is not because there are so few architectures, but so many. • We next look at several architectural disciplines in order to develop an intuition about software architecture. Specifically, we look at: • Building Architecture • Hardware Architecture • Network Architecture (c) Spiros Mancoridis

24. Building Architecture • Multiple Views: skeleton frames, detailed views of electrical wiring, etc. Various levels of abstraction. • Architectural Styles: Classical, gothic Romanesque, and so on. Various constraints on design. • Materials: One does not build a skyscraper using wooden posts and beams. Problems with implementation using available tools. (c) Spiros Mancoridis

25. King Henry 1V, Act 1, Scene 3 • LORD BARDOLPH: • When we mean to build, we first survey the plot, then draw the model; And when we see the figure of the house, then must we rate the cost of the erection; which if we find outweighs ability, what do we then but draw anew the model in fewer offices, or at last desist to build at all? (c) Spiros Mancoridis

26. Hardware Architecture • RISC machines emphasize a small fast instruction set as an important feature. • Complex instructions are implemented using this simple fast set. • Pipelined and multi-processor machines emphasize the configuration of architectural pieces of the hardware, and the overlapped flow of instruction and operation. (c) Spiros Mancoridis

27. Hardware Architecture • Micro-coded machines employ a fast interpreter to translate from a rich end user instruction set, to the underlying instruction set. They can emulate many machine architectures. • Pentium incorporates all of the logic to perform dynamic memory allocation, page faults etc. within its hardware. (c) Spiros Mancoridis

28. Differences & Similarities Between SW & HW Architectures • Differences: • relatively (to software) small number of design elements, resulting in greater reuse. • scale is achieved by replication of design elements. • Similarities: • we often configure software architectures in ways analogous to hardware architectures. (e.g., we create multi-process software and use pipelined processing). (c) Spiros Mancoridis

29. Network Architecture • Networked architectures are achieved by abstracting the design elements of a network into nodes and connections. • Topology is the most emphasized aspect: • Star networks • Token ring networks • Manhattan Street networks • Unlike software architectures, in network architectures only few topologies interesting (c) Spiros Mancoridis

30. Network Architecture • Synchronous versus asynchronous communication. • Unreliable communication versus reliable communication. • Layered communications protocol. • Re-use of software: eg: TCP/IP has TCP using the IP protocol to make unreliable communication, reliable. (c) Spiros Mancoridis

31. Architectural Styles of Software Systems (c) Spiros Mancoridis

32. Architectural Styles of Software Systems • An Architectural Style defines a family of systems in terms of a pattern of structural organization. It determines: • the vocabulary of components and connectors that can be used in instances of that style, • a set of constraints on how they can be combined. For example, one might constrain: • the topology of the descriptions (e.g., no cycles). • execution semantics (e.g., processes execute in parallel). (c) Spiros Mancoridis

33. Determining an Architectural Style • We can understand what a style is by answering the following questions: • What is the structural pattern? (i.e., components, connectors, constraints) • What is the underlying computational model? • What are the essential invariants of the style? • What are some common examples of its use? • What are the advantages and disadvantages of using that style? • What are some of the common specializations of that style? (c) Spiros Mancoridis

34. Describing an Architectural Style • The architecture of a specific system is a collection of: • computational components, • description of the interactions between these components (connectors). (c) Spiros Mancoridis

35. Describing an Architectural Style (Cont’d) • software architectures are represented as graphs where nodes represent components: • procedures • modules • processes • tools • databases • and edges represent connectors: • procedure calls • event broadcasts • database queries • pipes (c) Spiros Mancoridis

36. Software Architecture Topics • Architectural Styles of Software Systems: • Layered • Layered by language • Pipe and Filter • Object-Oriented • COM/OLE objects • Event driven • Table driven • Implicit Invocation (c) Spiros Mancoridis

37. Software Architecture Topics • More Styles of Software Systems: • Client-Server • Interpreter • Repository • Process-Control • Co-routines • Bootstrapped • Iteratively extended (c) Spiros Mancoridis

38. Layered Style • Suitable for applications that involve distinct classes of services that can be organized hierarchically. • Each layer provides service to the layer above it and serves as a client to the layer below it. • Only carefully selected procedures from the inner layers are made available (exported) to their adjacent outer layer. (c) Spiros Mancoridis

39. Layered Style (Cont’d) • Components: are typically collections of procedures. • Connectors: are typically procedure calls under restricted visibility. (c) Spiros Mancoridis

40. Layered Style (Cont’d) (c) Spiros Mancoridis

41. Layered Style Specializations • Often exceptions are be made to permit non-adjacent layers to communicate directly. • This is usually done for efficiency reasons. (c) Spiros Mancoridis

42. Layered Style Examples • Layered Communication Protocols: • Each layer provides a substrate for communication at some level of abstraction. • Lower levels define lower levels of interaction, the lowest level being hardware connections (physical layer). • Operating Systems • Unix (c) Spiros Mancoridis

43. Unix Layered Architecture (c) Spiros Mancoridis

44. Layered Style Advantages • Design: based on increasing levels of abstraction. • Enhancement: since changes to the function of one layer affects at most two other layers. • Reuse: since different implementations (with identical interfaces) of the same layer can be used interchangeably. (c) Spiros Mancoridis

45. Layered Style Disadvantages • Not all systems are easily structured in a layered fashion. • Performance requirements may force the coupling of high-level functions to their lower-level implementations. • Adding layers increases the risk of error. • Eg. getchar() doesn’t work correctly on Linux if the code is interrupted, but read() does. (c) Spiros Mancoridis

46. Layered by language • Different languages meet very different needs. • It is sometimes useful to layer software according to language layers. • The languages employed define the interfaces between layers. (c) Spiros Mancoridis

47. Layered language example • The web. • HTML • ASP • VBScript • OLE • OLE/DB • C++ (c) Spiros Mancoridis

48. Pipe and Filter Architectural Style • Suitable for applications that require a defined series of independent computations to be performed on ordered data. • A component reads streams of data on its inputs and produces streams of data on its outputs. • Very little feedback available from later operations applied to data. (c) Spiros Mancoridis

49. Pipe and Filter Architectural Style (Cont’d) • Components: called filters, apply local transformations to their input streams and often do their computing incrementally so that output begins before all input is consumed. • Connectors: called pipes, serve as conduits for the streams, transmitting outputs of one filter to inputs of another. (c) Spiros Mancoridis

50. Pipe and Filter Architectural Style (Cont’d) (c) Spiros Mancoridis