“Event partitioning”的意思、由来-开放百科全书

Event partitioning is an easy-to-apply systems analysis technique that helps the analyst organize requirements for large systems into a collection of smaller, simpler, minimally-connected, easier-to-understand "mini systems" / use cases.

Overview

The event-partitioning approach is explained by Stephen M. McMenamin and John F. Palmer in Essential Systems Analysis.^[1] A brief version of the approach is described in the article on Data Flow Diagrams (DFDs). A more complete discussion is in Edward Yourdon's Just Enough Structured Analysis.^[2] The description focuses on using the technique to create data flow diagrams, but it can be used to identify use cases as well.

The premise of event partitioning is that systems exist to respond to external events: identify what happens in the business environment that requires planned responses, then define and build systems to respond according to the rules of the business. In particular, a business system exists to service the requests of customers. A customer, in the jargon of the Unified Modeling Language (UML), is an "actor".

Event partitioning topics

Actor → Event → Detect → Respond

The technique was extended with "non-event" events by Paul T. Ward and Stephen J. Mellor in Structured Development for Real-Time Systems: Essential Modeling Techniques.^[3]

Data dictionary notation

Yourdon/DeMarco style of [https://web.archive.org/web/20070723121403/http://yourdon.com/strucanalysis/wiki/index.php?title=Chapter_10#DATA_DICTIONARY_NOTATION data dictionary notation] may be used to describe the composition and structure of data.

The data structure elements can map to structured programming′s control structures:

NB. The items defined may be "material" (e.g., room key) as well as "data" (e.g., arrival date-time).

Identifying Requirements and Their Reasons

The event-response information may be captured in a table. The event is the raison d’être for the response, which gives "traceability" from the response back to the environment.

Defining requirements

This approach helps the analyst to decompose the system into "mentally bite-sized" mini-systems using events that require a planned response. The level of detail of each response is at the level of "primary use cases". Each planned response may be modelled using DFD notation or as a single use case using use case diagram notation.

The basic flow within a process or use case can usually be described in a relatively small number of steps, often fewer than twenty or thirty, possibly using something like "structured English". Ideally, all of the steps would be visible all at once (often a page or less). The intention is to reduce one of the risks associated with short-term memory, namely, forgetting what is not immediately visible ("out of sight, out of mind").

Alternatively, using the notations of structured techniques, an analyst could create a "Nassi–Shneiderman diagram". In the UML, the use case could be modelled using an activity diagram, a sequence diagram, or a communication diagram. This could be problematic if there are many complex scenarios of the use case; the analyst may wish to model all or most of the scenarios.

Complexity versus fragmentation

If the response is lengthy or complex (i.e., more than a page of text), an analyst may decompose ("factor out" or deduplicate) into smaller "secondary use cases" to keep the "parent" primary use case smaller and simpler. These secondary use cases may prove to be reusable as well. (In a UML use case diagram, they would be drawn as extended or included use cases, which are related to one or more primary use cases.)

While describing a use case, an analyst may also uncover "business rules". Some analysts suggest capturing business rules in a separate document using the Object Constraint Language or some other formal notation. Then when a business rule must be obeyed in a use case, the analyst makes reference to it. This minimises repetition ^[10] within a specification, but risks fragmentation of a specification. One technique that may reduce this tension is to use hyperlinks in the specification document.

This reductionist approach lies somewhat in contrast to a systems thinking approach as represented by Peter Checkland's soft systems methodology.

In addition to functional requirements captured in a use case description, an analyst may include such non-functional requirements as response time, learnability, etc.

See also

References

1. ^MCME-84: {{cite book | first = Stephen M. | last = McMenamin |author2=John F. Palmer | year = 1984 | title = Essential Systems Analysis | publisher = Prentice-Hall (Yourdon Press) | isbn = 0-13-287905-0}} ({{ISBN|978-0-13-287905-7}})
2. ^YOUR-89: {{cite web |url=http://yourdon.com/strucanalysis/wiki/index.php?title=Chapter_18#CONSTRUCTING_THE_ENVIRONMENTAL_MODEL |title=yourdon.com - Just Enough Structured Analysis, Chapters 18, 19 |year=1989}}
3. ^WARD-85: {{cite book | first = Paul T. | last = Ward |author2=Stephen J. Mellor | year = 1985 | title = Structured Development for Real-Time Systems: Volume 2, Essential Modeling Techniques | publisher = Prentice-Hall (Yourdon Press) | isbn = 0-13-854787-4}} ({{ISBN|978-0-13-854787-5}})
4. ^WARD-85, pp. 38-39.
5. ^booking dialogue = * *
     = *input* booking request + *output* booking confirmation
booking request = * *
     = guest name + room type + (room facilities) +
       arrival date-time + departure date-time
room type = * type of bedroom *
     = * values : [ single ; double ; family ] *
room facilities = * booleans that indicate presence or absence of a facility *
     = television + radio + alarm clock + climate control + Internet access +
       telephone + refrigerator + mini-bar + toilet + sink + bath + shower + bidet
arrival date-time = * *
     = date-time
departure date-time = * *
     = date-time
date-time = * ISO 8601 format *
     = year + month + day of month + 'T' + hour + minute >
6. ^cancellation dialogue = * *
     = *input* cancellation request + *output* cancellation confirmation
7. ^arrival dialogue = * *
     = *input* arrival message + *output* arrival packet
arrival packet = * *
     = room key + room card + complimentary drink coupon
8. ^check-out dialogue = * *
     = *input* check-out request + *output* guest bill
9. ^payment dialogue = * *
     = *input* payment vehicle + *output* guest receipt
guest receipt = * *
     = guest name + guest address + {charge detail} + charge total + (taxes) + amount due + amount paid
10. ^see also Don%27t_repeat_yourself, also known as "DRY"