LARMAN CD MODULES

Module 9

Large Scale System Design

Introduction

So having moved from the Analysis phase to the Design Phase, this module takes a look at designing systems in the "large", that is we will look at the large scale partitioning of the software system before drilling down the the detailed object design. In fact, the modules coming up focus on designing objects in the domain layer.

So, at the end of this module will be understand something about the layers pattern and the logical partitioning of the system using UML Package diagrams.

System Partitioning

A common element of system partitioning is the element of "architecture" and the identification of large scale elements (LSEs). These are:

- layers
- subsystems
- modules
- frameworks

The reason why we consider the LSEs at this stage in the process is because it is useful before moving into the detailed design of objects to have a draft design of the large scale elements detailing:

- the large scale elements
- the interfaces
- the inter-element collaborations

Of course, in iterative development, these will be further refined later as the major objective of the UP Elaboration Phase is to stabilize the big architectural decisions.

The Layers Pattern

Firstly, a small discussion on patterns. A pattern is an important concept in software design. Basically, it is the idea of taking a well-known best-practice solution to a large or small scale problem and recording and reusing these, rather than coming up with a solution from scratch each time. The name pattern implies repeated use.

The Layers Pattern is a large scale architectural pattern which suggests that a suitable way to design a system is in terms of major components or layers with a focused and cohesive set of concerns.

For example, a UI layer or presentation layer which just focuses on presentation concerns. This layer would be distinct from the application logical or domain layer software components which focus on the implementation of the core logic of the system. Also, you would place other subsystems in separate places for example, placing the persistence components in a services layer.

UML Package Diagrams

In terms of the UML we can use package diagrams to depict the layering of large scale elements from the static point of view. The diagram shows LSEs as folders which can in turn contain smaller sub-elements. For example, within the Presentation layer there will be a sub-element which focuses on the Swing component etc. The big idea is that on a logical level, we express the LSEs using a package diagram.

Further to the above static package diagram, we can also show the dependencies between packages, that is the coupling that one package has to another, using UML Package notation. When we make changes to one package, we can see what other packages may be affected:

Large Scale Early Dynamic System Design

What we have previously been looking at in this module is the early static system design. At this point the dynamics are unstable and speculative. It won't be until later in the elaboration phase where the dynamics are focused on via iterations and can be evaluated for load/stress/evolution.

Ordering of Work by Package Dependencies

If we look at the UML package notation above, the one with the dependencies flows, it can give us a clue as to the order in which work may be done. For example, the Persistence component is not dependent on any other package or module and therefore it looks like a pretty good choice to start first.

Home

Module 1 | Module 5 | Module 6 | Module 7 | Module 8 | Module 9

Module 10 | Module 12 | Module 13 | Module 14