Problem Frames Approach
|
Problem Analysis or the Problem Frames Approach is an approach to software requirements analysis. It was developed by British software consultant Michael A. Jackson. It was first sketched in his book Software Requirements & Specifications (1995) and described much more fully in his book Problem Frames: Analysing and Structuring Software Development Problems (2001).
Contents |
Fundamental Philosophy
Problem analysis or the Problem Frames approach is an approach — a set of concepts — to be used when gathering requirements and creating specifications for computer software. Its basic philosophy is strikingly different from other software requirements methods in insisting that:
- The best way to approach requirements analysis is through a process of parallel — not hierarchical — decomposition of user requirements.
- User requirements are about relationships in the real world; not about functions that the software system must perform.
The Problem Context
Problem analysis considers a software application to be a kind of software Machine. The goal of a software development project is to change the real world by creating a software Machine and adding it to the real world, where it will bring about certain desired effects.
The particular portion of the real world that is of interest in connection with a particular problem — the particular portion of the real world that forms the context of the problem — is called the application domain.
After the software development project has been finished, and the software Machine has been inserted into the real world, the problem context will contain both the application domain and the Machine. At that point, the situation will look like this:
ProblemFramesProblemContext1.png
The problem context contains the Machine and the application domain. The machine interface is where the Machine and the application domain meet and interact.
The same situation can be shown in a different kind of diagram, a context diagram, this way:
The Context Diagram
The problem analyst's first task is to truly understand the problem. That means understanding the context in which the problem is set. And that means drawing a context diagram.
Here is Jackson's description of examining the problem context, in this case the context for a bridge to be built:
- You're an engineer planning to build a bridge across a river. So you visit the site. Standing on one bank of the river, you look at the surrounding land, and at the river traffic. You feel how exposed the place is, and how hard the wind is blowing and how fast the river is running. You look at the bank and wonder what faults a geological survey will show up in the rocky terrain. You picture to yourself the bridge that you are going to build. (Software Requirements & Specifications: "The Problem Context")
An analyst trying to understand a software development problem must go through the same process as the bridge engineer. He starts by examining the various problem domains in the application domain. These domains form the context into which the planned Machine must fit. Then he imagines how the Machine will fit into this context. And then he constructs a context diagram showing his vision of the problem context with the Machine installed in it.
The context diagram shows the various problem domains in the application domain, their connections, and the Machine and its connections to (some of) the problem domains. Here is what a context diagram looks like.
This diagram shows:
- the Machine to be built. The dark border helps to identify the box that represents the Machine.
- the problem domains that are relevant to the problem.
- the solid lines represent domain interfaces — areas where domains overlap and share phenomena in common.
A domain is simply a part of the world that we are interested in. It consists of phenomena — individuals, events, states of affairs, relationships, and behaviors.
A domain interface is an area where domains connect and communicate. Domain interfaces are not data flows or messages. An interface is a place where domains partially overlap, so that the phenomena in the interface are shared phenomena — they exist in both of the overlapping domains.
You can imagine domains as being like primitive one-celled organisms (like amoebas). They are able to extend parts of themselves into pseudopods. Imagine that two such organisms extend pseudopods toward each other in a sort of handshake, and that the cellular material in the area where they are shaking hands is mixing, so that it belongs to both of them. That's an interface.
In the following diagram, X is the interface between domains A and B. Individuals that exist or events that occur in X, exist or occur in both A and B.
ProblemFramesInterfaces.png
Shared individuals, states and events may look differently to the domains that share them. Consider for example an interface between a computer and a keyboard. When the keyboard domain sees an event Keyboard operator presses the spacebar the computer will see the same event as Byte hex("20") appears in the input buffer.
Problem Diagrams
The problem analyst's basic tool for describing a problem is a problem diagram. Here is a generic problem diagram.
In addition to the kinds of things shown on a context diagram, a problem diagram shows:
- a dotted oval representing the requirement to bring about certain effects in the problem domains.
- dotted lines representing requirement references — references in the requirement to phenomena in the problem domains.
An interface that connects a problem domain to the Machine is called a specification interface and the phenomena in the specification interface are called specification phenomena. The goal of the requirements analyst is to develop a specification for the behavior that the Machine must exhibit at the Machine interface in order to satisfy the requirement.
Here is an example of a real, if simple, problem diagram.
This problem might be part of a computer system in a hospital. In the hospital, patients are connected to sensors that can detect and measure their temperature and blood pressure. The requirement is to construct a Machine that can display information about patient conditions on a panel in the nurses station.
The name of the requirement is "Display ~ Patient Condition". The tilde (~) indicates that the requirement is about a relationship or correspondence between the panel display and patient conditions. The arrowhead indicates that the requirement reference connected to the Panel Display domain is also a requirement constraint. That means that the requirement contains some kind of stipulation that the Panel display must meet. In short, the requirement is that The panel display must display information that matches and accurately reports the condition of the patients.
Problem Frames
A problem frame is a description of a recognizable class of problems, where the class of problems has a known solution. In a sense, problem frames are problem patterns.
Jackson identifies five problem frames in chapter 4 of his book Problem Frames.
- required behavior
- commanded behavior
- information display
- simple workpieces
- transformation
Each problem frame has its own problem frame diagram. A problem frame diagram looks essentially like a problem diagram, but instead of showing specific domains and requirements, it shows types of domains and types of requirements.
Required Behavior Problem Frame
The intuitive idea behind this problem frame is:
- There is some part of the physical world whose behavior is to be controlled so that it satisfies certain conditions. The problem is to build a machine that will impose that control.
ProblemFramesRequiredBehaviorFrame.png
Commanded Behavior Problem Frame
The intuitive idea behind this problem frame is:
- There is some part of the physical world whose behavior is to be controlled in accordance with commands issued by an operator. The problem is to build a machine that will accept the operator's commands and impose the control accordingly.
ProblemFramesCommandedBehaviorFrame.png
Information Display Problem Frame
The intuitive idea behind this problem frame is:
- There is some part of the physical world about whose states and behavior certain information is continually needed. The problem is to build a machine that will obtain this information from the world and present it at the required place in the required form.
Simple Workpieces Problem Frame
The intuitive idea behind this problem frame is:
- A tool is needed to allow a user to create and edit a certain class of computer-processable text or graphic objects, or similar structures, so that they can be subsequently copied, printed, analyzed or used in other ways. The problem is to build a machine that can act as this tool.
Transformation Problem Frame
The intuitive idea behind this problem frame is:
- There are some given computer-readable input files whose data must be transformed to give certain required output files. The output data must be in a particular format, and it must be derived from the input data according to certain rules. The problem is to build a machine that will produce the required outputs from the inputs.
Variant frames
In Problem Frames Jackson discusses variants of these basic problem frames. A variant typically adds a domain to the problem context.
- a description variant introduces a description lexical domain
- an operator variant introduces an operator
- a connection variant introduces a connection domain between the machine and the central domain with which it interfaces
- a control variant introduces no new domain; it changes the control characteristics of interface phenomena
Problem Concerns
Jackson also discusses certain kinds of concerns that arise when working with problem frames.
Particular Concerns (Problem Frames Chapter 9)
- overrun
- initialization
- reliability
- identities
- completeness
Composition Concerns (Problem Frames Chapter 11)
- commensurable descriptions
- consistency
- precedence
- interference
- synchronization
Problem Analysis and the Software Development Process
When problem analysis is incorporated into the software development process, the software development lifecycle starts with the problem analyst, who studies the situation and:
- creates a context diagram
- gathers a list of requirements and adds a requirements oval to the context diagram, creating a grand "all-in-one" problem diagram. (However, in many cases actually creating an all-in-one problem diagram may be impractical or unhelpful: there will be too many requirements references criss-crossing the diagram to make it very useful.)
- decomposes the all-in-one problem and problem diagram into simpler problems and simpler problem diagrams. These problems are projections, not subsets, of the all-in-one diagram.
- continues to decompose problems until each problem is simple enough that it can be seen to be an instance of a recognized problem frame. Each subproblem description includes a description of the specification interfaces for the machine to be built.
At this point, problem analysis — problem decomposition — is complete. The next step is to reverse the process and to build the desired software system though a process of solution composition.
The solution composition process is not yet well-understood, and is still very much a research topic. Extrapolating from hints in Software Requirements & Specifications, we can guess that the software development process would continue with the developers, who would:
- compose the multiple subproblem machine specifications into the specification for a single all-in-one machine: a specification for a software machine that satisfies all of the customer's requirements. This is a non-trivial activity — the composition process may very well raise composition problems that need to be solved.
- implement the all-in-one machine by going through the traditional code/test/deploy process.
Similar Approaches
There are a few other software development ideas that are similar in some ways to problem analysis.
- The notion of a design pattern is similar to Jackson's notion of a problem frame. It differs in that a design pattern is used for recognizing and handling design issues (often design issues in specific object-oriented programming languages such as C++ or Java) rather than for recognizing and handling requirements issues.
- Aspect-Oriented Programming, AOP (also known as Aspect-Oriented Software Development, AOSD) is similarly interested in parallel decomposition, which addresses what AOP proponents call cross-cutting concerns or aspects. AOP addresses concerns that are much closer to the design and code-generation phase than to the requirements analysis phase.
- Martin Fowler's book Analysis Patterns is very similar to problem analysis in its search for patterns. It doesn't really present a new requirements analysis method, however. And the notion of parallel decomposition — which is so important for problem analysis — is not a part of Fowler's analysis patterns.
External links
- http://dspace.dial.pipex.com/jacksonma/ is Michael A. Jackson's home page
- http://www.ferg.org/pfa/ has papers and articles on the Problem Frames Approach