COMP 310	Use Case-driven System Block Diagrams

For information on Use Cases, see the Java Resources page on Use Cases.

System Block Diagrams

("System block diagram" is the the more hardware-oriented term which emphasizes functionalities and intercommunications. For software engineering, some will call this sort of diagram a "software block diagram" or simply a "block diagram".)

A system block diagram is a high level modularization of the system that separates the overall system into maximally decoupled sub-systems.    System block diagrams enable one to visualize the system as large interacting components that can be conceptualized and developed independently.   This type of architecture also lends itself to greater flexibility and extensibility of the system, enabling it to grow and evolve more easily to adjust for changing requirements and demands.   Creating a system block diagram early in the development process is critical for assembling teams of develops that can work in parallel on the project.

A system block diagram displays the high-level view of the encapsulated functional modules that compose a system.   A system block diagram may show multiple layers of encapsulation, though internal layers are often relegated to separate diagrams for clarity's sake.   In terms of system design, the modules in the system block diagram should exhibit maximal decoupling from each other.

System block diagrams help the developers understand the the parts fit into the larger whole.   They are also very useful in helping maintain the proper level of decoupling in the system because excessive crossing of module boundaries will result in a "spaghetti diagram".

A system block diagram minimally consists of the following information:

• The  functional modules in the system, indicated by colored, titled shapes 
  • Each module should have a description of exactly what it is and what it does, i.e. its roles and responsibilities in the system.
• Communications pathways between modules, indicating the directional flow of data and control information from one module to another.
• Delineations of various boundaries in the system, both physical,e.g. in hardware, or virtual, e.g. in software libraries or packages/namespaces.

The key to creating an effective system block diagram is the clear and complete articulation of the decoupled processes that compose the system.  -- You cannot develop your system if you do not completely understand the functional modules of which it is comprised.

System Block Diagram References:

• Block Diagram (Wikipedia article -- a bit more general than we are discussing)
• Software Block Diagram images:   Google,   Bing

From Use Cases to System Block Diagrams

One of the best ways to generate a system block diagram is to approach it from use cases.   By grouping use cases together, the functional modules of the system will emerge.  Excessive coupling can easily be identified in the resulting diagram and the use cases and associated modules can then be modified to be more streamlined.

1. Put all the use cases for the system into a single diagram.  
   • For large use case sets, some generalization may be needed to make the diagram more manageable, but in the end, every use case must be tested in terms of being represented by the resulting diagram.
2. Re-arrange the use case graph to group functionally and/or conceptually related operations.
3. Draw modular encapsulations around the related use case operations.
   • The lines between modules are the required communications pathways.
   • Write down the definition each module in terms of what it is and what it does (roles and responsibilities).
4.  Modify use cases to create maximal decoupling between the modules.  
   • Maximal decoupling means that for any given module, it
     • communicates with a minimum number of other modules
     • communicates in a minimum number of ways with any other module -- strive for abstract communications ("is" many things), not universal communications ("does" many things).
   • Note that this sometimes requires the creation of new modules,  e.g. facades, proxies, "managers", etc.

Examples

(Note: the following diagrams show solid lines with solid arrowheads to indicate that one use case "uses" another use case.   Technically, those lines should be dotted lines with solid arrowheads as per the UML standard.)

Use case-driven system block diagram:

Notice how the use cases have been organized into the system block diagram.   (This diagram is the original diagram for a class project, made by the students who used the wrong arrowheads in the drawing.   The closed arrowheads shown should in fact all be open arrowheads.)

Click for full-size image

System block diagram without use cases being shown

Note lack of critical details.   (Once again, this is the original diagram for a class project where the students used the arrowheads that are not clearly the open arrowheads as they should be.)

Click for full-size image

© 2017 by Stephen Wong