An Introduction No other software engineering language construct
with as much impact as use cases has been adopted so quickly and
so widely as use cases have. I believe this is because use cases,
although a simple idea, play a role in so many different aspects
of software engineering. So many people have asked me how I came
up with tuse case idea that I will briefly describe it here. I'll
also sumwhat we have achieved so far with use cases, then suggest
a fewimprovements for the future. he marize
Yesterday: In The Beginning
Use cases have now been around for more than 16 years. When I first
used the term in 1986, they were the evolution of work ongoing since
Getting to Use Cases
It was 1986; I was troubled by how to model telephone calls. A modern
switch at that time offered so many types of telephone calls: local
calls, outgoing calls, incoming calls, and transit calls. There
were many kinds of local calls; and many kinds of outgoing calls:
calls to a neighbor switch, to a domestic switch, to an international
switch. And, on top of this, each one of these calls could be carried
out with different signaling systems.
We had discovered the problem of multiplicity and diversity many
years ago. We didn't model each type of call—there were too many,
and there was a lot of overlap between them—we just listed and named
all of them: we called them traffic cases. Instead, we modeled the
different “functions” we needed to carry out all of the calls. A
function was some loosely defined piece of software. Functions had
no interfaces. They had beginnings and endings, but they were not
well defined. A function could interact with the outside world.
The general feeling was that we didn't really know what functions
were, but we could give examples of them, and some people could
However, we did know how to realize functions. I had learned a
diagramming technique that described sequences of relay operations.
In 1969 I translated this technique to software to describe component
interactions—to what is today called sequence diagrams—the same
term used when they were introduced. We described how functions
were realized by using sequence diagrams (or collaboration diagrams
for simpler interactions) in very much the same way that we describe
use case realizations today.
Then, one day in spring of 1986, while working on traffic cases
and trying to map them onto functions, I suddenly got it. A traffic
case could be described in terms of functions by using an inheritance-like
mechanism. I changed the terminology and made traffic cases and
functions both use cases—the former became concrete or real use
cases, the latter became abstract use cases.
I wrote a paper on this for OOPSLA'86; this paper is where I introduced
use cases. The paper was not accepted (probably because I already
had another paper for that conference, or because most people in
the program committee were programming language experts). However,
the paper was accepted for OOPSLA'87. This paper introduced many
of the key ideas in use-case modeling.
What Was a Use Case in 1987?
According to the OOPSLA'87 paper “a use case is a special sequence
of transactions, performed by a user and a system in a dialogue.”
This is pretty similar to our current (informal) definition. I developed
a separate model for describing an outside perspective of a system
and I called it a use-case model. By outside, I meant a black-box
view of the system—the internal structure of the system would be
of no interest in this model. Some people have misunderstood the
term “outside” and believed it to be a synonym for user interface—which
it was not. Instead it represented a model of the functional requirements
of the system.
At this time the use-case model also included entity (domain)
objects, thus we could show how use cases could <<access>>
entities. Use cases and entities were class-like (with operations)
and not data. The other relation in the use case model was <<built-on>>
which was described as “an extended form of inheritance relation.
Multiple inheritances are common.” In fact, the built-on relation
was a combination of the generalization relationship and the <<extend>>
Use cases were not just specified, but also designed and tested.
“You create as many processes [we would today say activities] as
there are use cases. The conceptual model of the use cases is translated
seamlessly into a new model showing how each use case is implemented
by means of the identified blocks [a block would today be subsystem,
class, or component].” This sounds pretty much like collaborations.
“Each use case is tested separately to safeguard that the system
meets the requirements of the user. Please, note that the use cases
constitute the key aspect through the entire development activities.”
Sequence diagrams were used to show the interactions among the
blocks/components. This is no surprise since sequence diagrams had
shown their value in practice for almost twenty years by then.
What Was a Use Case by 1992?
In 1992 the OOSE book, Object-Oriented Software Engineering—a Use
Case Driven Approach,1 was published. During 1987 and 1992 the Objectory
process had been in practical use by about twenty customers for
important new product development. These customers were involved
in many different kinds of systems: management information systems,
defense systems (pilot, counter measure, C3I), and telecom systems
(POTS, mobile). What was presented at OOPSLA′87 was theory, now
we had a lot of practical experience behind the idea. Over these
five years use cases had matured.
Thus, use cases took much of their current shape (syntax and semantics)
before 1992. At that time we had use cases, actors, use-case models,
the relationships “inheritance” (now replaced by “generalization”)
and <<extend>>. I didn't like what we today call the
<<include>> dependency since I thought it would damage
modeling by inviting functional decomposition.
To increase clarity we made it an important issue to distinguish
between a use case (as a class-like thing), an instance of a use
case, and a description of a use case.
The depth of the use-case model was in its use cases. Each use-case
description contained the following:
? a brief description
? a flow of control
? base flows and alternative flows
? subflows (reusable at many places within the same use-case description)
? preconditions and postconditions
However, use cases were more than a requirements technique. Use
cases were like the hub of a wheel2:
Figure 1. Use Cases Were Like the Hub of a Wheel
Use cases were traceable to analysis, to design, and to implementation
and test. For each use case in the use-case model we created a collaboration
(a view of participating classes) in analysis and design. Each use
case resulted in a set of test cases. Use cases were important to
design user interfaces and to structure the user manual. Use cases
also moved into the space of business modeling, since they perfectly
matched the definition of business processes.
We coined the term use-case driven development for our approach
of software development—first identifying all use cases and specifying
each one of them in requirements, analyzing and designing each one
of them in analysis and design respectively, and finally testing
each and every one of them in test.
We had all this before 1992!
Today: A Lot Has Happened Since Then
The adoption rate of use cases has surprised me: they were embraced
almost immediately by all methodologists, and basically adopted
worldwide. Other important techniques such as component-based design
and object-oriented modeling were much more controversial and needed
a much longer adoption time. Probably this is because use cases
are basically a simple and obvious idea; they work well with objects
and object thinking. Using use cases is not just a technique for
managing requirements, but it binds together all the activities
within a project—whether this project is a miniproject like a single
iteration, or a major project resulting in a new product release.
The current definition of use cases basically goes back to 1994.
To strike a balance between defining too many use cases or too few,
I added a requirement that a use case must give a “measurable value”
to a “particular actor.” As a rule of thumb, I suggested that a
large system supporting one business process should have no more
than, say, 20 use cases. I realized that giving any such number
could lead people to take undesirable actions to get the “right”
number. If they had less than 20 use cases, they might split some
of them get up to a count of 20; or, if they had more than 20 use
cases, they might combine separate use cases to get down to a count
of 20. But that is the wrong approach. I have seen good use-case
models for commercial systems with as few as 5 use cases and some
with as many as 40 use cases. However, I have also seen use-case
models with as many as 700 use cases—obviously these were unsound
models. My suggested 20 use cases are concrete (real) use cases
and not generalizations, or extension/inclusion fragments.
Use cases have become part of the Unified Modeling Language (UML).
Because the UML is precisely defined, the meaning of use cases and
associated concepts (such as use-case instance [UCI]) could also
be precisely defined thanks to the UML's powerful classifier concept.
What I called “class-like” in 1992 could now be formally explained
by UML classifiers. We no longer needed to only rely on the old
definition that “a use case is a sequence of actions…” Although
this is still a compatible definition from the user's perspective,
the definition based on classifiers is what methodologists, process
engineers, and tool builders need for clarity. Thus the UML effort
resulted in a much more precise definition of use cases, but it
didn't do much to evolve them. Roughly speaking we only changed
the “uses” relation to a generalization, and we added
<<include>>. (The “uses” relation in Objectory was previously
called “inheritance” and was never intended to be used as <<include>>
fragments.) In the past we didn't allow developers to model these
fragments, but used another technique involving text objects instead;
we'll discuss these later.
I am very happy with the way our Rational Unified Process (RUP)
team has correctly implemented use cases and improved their practical
use. No really dramatic changes have been made, but use cases have
evolved to be better explained, based on the experience of thousands
of customers and our own experts. In particular, a new book, Use
Case Modeling3, by Kurt Bittner and Ian Spence, is now on the shelves.
This is THE book on use cases. I strongly recommend everyone involved
in software engineering and requirements development read it. Also
Kelli Houston's RUP work on user experience design with use cases
is a great improvement on our earlier work in this area, and is
very much in line with the original use case concept.
Thus, now may be the time to take some steps forward to grow (clarify
and extend) the idea of use cases. But first, a word of warning
about formalizing use cases.
Use Caution When Formalizing Use Cases
Over the years people have criticized use cases for not having
a formal enough description in the UML. Although several of my papers
discuss techniques for formalizing use cases, such as using sequence
diagrams to show how an actor interacts with a use case, or using
activity diagrams or state charts to describe a single use case,
I warned against using these techniques. After all, the use-case
model is intended for communicating with customers and users. Formalizing
use cases (using mathematics) has never been a problem. I had already
done it in 1986. In fact, any computer science student could do
it. By making use cases classifiers in UML, you have the tool to
formally describe use cases to basically any depth you want.
The difficulty is, however, to use what is available in UML in
the most pragmatic way. I am still reluctant to suggest that system
analysts describe use cases more formally than in some textual form.
Avoid trying to specify the internals of each use case with diagrams
such as activity diagrams or state charts. You may describe the
interactions between a use case and actors using sequence diagrams
or activity diagrams with swimlanes. I think there are better ways
to become more precise about requirements (the internals of a use
case) than introducing more formalism in the use-case model. This
is the role of analysis—but that is the subject of another paper.
Tomorrow: Potential Next Steps
Over the last decade, the way use cases were written has remained
quite stable. Of course, over these years I have wanted to make
improvements, however, as soon as a change was discussed, everything
was questioned and things became too unsettled.
Therefore, I felt it safer to leave it as is, until people become
more familiar with the use case construct. Also, we needed to allow
time for use cases to be used in the field, and for their implementation
to evolve and become established. In this section, I will raise
a couple of issues with the current application of use cases, and
indicate some proposed changes.
Some Context for the Proposals
A use-case model of a software system contains basically four kinds
of use cases:
- concrete use cases: can be instantiated (abstract ones can't)
- generalization use cases: to support reuse of use cases
- extension use cases: add behavior to an existing (or presumed
existing) use case, without changing the original use case
- inclusion use cases: add behavior to other use cases, and do
so by changing them.
These use cases are abstract and generalizations of concrete use
cases (through the generalization relationship) or other abstract
use cases. The generalization use case (the parent use case) and
its sub-use cases (children) should be of the same type to obey
the principle of substitutability—you should be able to use an instance
of a child whenever you expect an instance of the parent. Now, this
is not quite true for use cases (or any state-driven classifier),
since a child use case can require some extra interaction with the
actors. However, the basic idea is the same: the child should be
of the same type (classification) as the parent. For example, Make
a Local Call and Make a Wake-Up Call are both generalized to the
abstract use case Make a Call.
Recall that extension use cases serve a very special purpose: they
add behavior to an existing (or presumed existing) use case, and
do so without changing it4. Using extensions is a technique to get
easy-to-understand descriptions. First you describe the basic (mandatory)
behavior, then you add extra (mandatory or optional) behavior—behavior
that is not needed to understand more basic behavior. In this way
you can start by describing some very simple basic behavior, and
then add more and more behavior without having to change the basics.
Extensions are not just a technique for describing optional behavior
(optional, that is, from the customer's point of view), they are
also intended for describing mandatory behavior in a structured
way. Without a mechanism like extensions the base flow of a use
case would become cluttered with statements that have nothing to
do with the base use case, even if the statements are important
for other use cases.
A potential problem in using extensions is creating deep hierarchies
of extend dependencies. To avoid these we need guidelines: we usually
never extend an extension (a fragment), since it would make them
difficult to understand.
Another potential point of confusion is knowing when to use extensions
and when to use alternative paths when describing a use case. Again,
we need guidelines: we usually only use the extend relationship
when the extension use case is completely separate from the extended
base use case—or, more precisely, when it is a separate concrete
use case in itself, or when it is only a small fragment also needed
by another use case. The base use case must be complete by itself
and not require the extension. Otherwise, you must use alternative
paths to describe additional behavior.
Extensions can help a lot in managing software development over
the entire software development lifecycle. For example, a large
class of extensions could be added without requesting regression
tests for the base—you would only need to test the extensions and
their cooperation with the existing base. Let me qualify this. First,
extensions as language constructs need to propagate through design
and implementation: they need to be added to the design model, the
implementation model, the executable code, and so on. (For further
information look up “extends” in the OOSE book.) Second, only extensions
that don't access other use cases' objects (more correctly, extensions
that don't modify objects shared with other use-case realizations)
would, for instance, belong to this class. When such conditions
are fulfilled we could prove that some extensions wouldn't be able
to damage the existing software.
I proposed the idea of extensions back in 1978 at Ericsson. Developers
didn't embrace the idea until 1991. They were first published at
OOPSLA 8656. But the idea had merit: Ericsson even applied for patents
to support extensions. Extensions to C++ and to the operating system—in
fact, also to the computer architecture—were suggested by our infrastructure
team. Extensions would lower the development costs significantly.
Further discussion is out of the scope of this paper, but the point
is this: don't think of extensions as useful for use cases only!
I hope to address in a forthcoming aspect-oriented paper how extensions
could propagate through activities other than use-case modeling—activities
such as analysis, design, implementation, and test. This was as
I said above actually already described in the OOSE book.
When use cases were born, the need for two kinds of reuse was seen.
Since I based use cases on object orientation, I saw great value
in subclassing, and in 1987 introduced what we called the “inheritance”
relation between use cases. In 1992 we changed this to “uses” to
make it less “techie” jargon and easier to adopt by analysts. In
the UML it was later called “generalization.” The other reuse need
was simply a mechanism for factoring common flows of events (sharing)
from use-case descriptions; for cases where we currently use the
<<include>> relation. This shared behavior is what I
here call an inclusion.
I was very reluctant to introduce a relation like this, since
I foresaw people misusing use cases by applying them as they did
functional decomposition. In fact, this is one of the threats to
use cases today. People misuse use cases by using them to describe
functions as opposed to objects, and then blame the use-case concept
for their problem. To get around this, we introduced another idea.
In the Objectory tool, we supported reuse through “text objects”7,
reusable objects consisting of a piece of text. These text objects
could only be changed by the person responsible for the text object,
not by someone else using (or reusing) the object.
Text objects could be reused in multiple places, for example in
different text descriptions of use cases. Like Rose/XDE, which has
a model element for each class that could be shown (differently
if needed) in multiple diagrams, text objects could be shown in
multiple documents. The beauty was that all the text objects were
kept in one place, so they were easy to find, change and manage,
and all references were automatically kept in sync. Very powerful!
I think that the solution we had was right at that time, when we
feared that use cases would be viewed as just another way to do
functions. This problem persists today among system analysts, although
not among methodologists.
Two Classes of Extension/Inclusion Use Cases
When extension use cases originally were introduced I had basically
only one kind of extension or inclusion in mind: the small reusable
use-case fragment. I didn't foresee the need for being able to extend
or include concrete complete use cases. This is something we learned
during the first four years of practical use. Many times we8 discussed
the need for two kinds of extension use cases. However, we didn't
want to make use-case modeling more complex. During the UML 1.1
work we (primarily Jim, Gunnar and I) touched on this subject, but
for the same reason we didn't follow through. Maybe now is the time?
There are two classes of extension/inclusion use cases:
- ones that are concrete (complete) use cases in themselves
- ones that are just fragments of a use case
Extensions/inclusions that are concrete use cases in themselves.
These use cases interact with actors and can be said to provide
value to an actor. As an example9, consider a “surveillance” system
that reports intruders. The base (concrete use case) monitors the
surveillance area, and perhaps even does some other work, such as
maintaining a constant building temperature. The extending use case
(also a concrete use case) reports unusual events—security breaches
or fires—to the appropriate authorities (police, fire, building
management). This illustrates that the base use case has some significant
behavior, as does the extending use case—they are both concrete
use cases, and they can both be instantiated.
Extensions/inclusions that are just fragments of a use case. This
is a far larger class of use cases, but each member is usually very
small. These use cases are abstract in that they cannot be instantiated
separately. They are needed by some other use case—usually a concrete
or a generalization use case. For example, in Figure 2, assume that
the base use case is a bank transaction Conduct Transaction. Every
time a transaction fails the bank wants to register this event to
make it available to some other concrete use case, in this case,
an administrative use case Inspect Transaction Failures. One obvious
traditional solution would be to change the transaction use case
and thus explicitly in its description show that a failure message
has been registered. However, this would require changing the base
and complicating its understanding. The change has nothing to do
with the base use case Conduct Transaction; it's only there to register
some information to the other use case. One such change may not
be disturbing, but when you have several of them it gets to be quite
messy. To avoid cluttering the base we instead use an extension
use cases to add the change on top of the base use case. We would
add a third use case—a very small use case fragment called Register
Failures. In a similar way we may have small procedure-call like
inclusion use cases that are shared between two or more concrete
use cases. Assume that Validate User is such an included use case
fragment (shared with some other real use case).
Figure 2. Concrete and Abstract Use Cases A part of a use-case
model with two concrete use cases: Conduct Transaction and Inspect
have introduced a dependency between the concrete use case Inspect
I have introduced a dependency between the concrete use case Inspect
Transaction Failures and the extension use case Register Failures.
Since this dependency is special and required only to attach an
extension fragment to the use case that needs it, it may be a good
idea to define a unique dependency stereotype (maybe <<need>>?)
for it. But that is a separate issue.
The first class of use cases—concrete use cases in themselves—is
fine, we don't need to do anything special about it. Concrete use
cases can extend a base use case or be included in a base use case.
The second class of use cases—the use case fragments, as I will
call them—will be discussed Extension and Inclusion Use Cases Have
a Lot in Common ing the “execution” of s the he major difference
between extension and inclusion use cases is the way the use case
-In the case of inclusion, the base flow itself explicitly instructs
the use case instance to obey the inclusion use case.
-In the case of extension, the base flow doesn't specify the interruption,
rather the extension use case specifies where in the base use case
the use case instance shall make the interruption.
The extension use case references an extension point, which specifies
a unique location in the base use case. In OOSE and Objectory, extension
points belonged to the extending use case. In the work on UML 1.1
Jim Rumbaugh suggested that extension points should belong to the
extended use case. The argument was for encapsulation—the extending
use case should not see the details of the base use case, just the
extension points. If you change the extended use case, only that
use case would know the new location. I agree with him.
Thus extension and inclusion use cases are very similar; in fact,
they could be considered the inverse of each other. Actually, when
working on UML 1.1, Jim and I discussed that this shoube reflected
in how the two dependencies were named. However, he was not crazy
about my proposal that <<include>> should be named <<inverse
extend>>, and I don't think anyone elswould have been either.
Thanks to the work on SDL in 1981, and now UML, we have come a
long way in developing more precise modeling languages.
Very simply: Classical language specifications (1) start from
a concrete syntactic construct (a ch ents e ince fragments are NOT
use cases, they should NOT be represented by the use-case syntax.
It ote, I have no good proposal for what the new notational elements
should look like. To suggest Figure 3. Treat Fragments Appropriately—As
notational element in UML), which is (2) mapped into an abstract
syntactic construct, and whiin turn is (3) mapped onto a semantic
element. The semantics specifies the meaning of the syntax. Most
interesting syntactic constructs have a unique semantic correspondence.
(The opposite is not necessarily true, since designed languages
usually have many semantic elem[dynamic semantics] that don't have
a syntactic correspondence.) Thus I think it is standard language
design practice to make every unique semantic element mappable from
a unique syntactic construct. Natural languages are much more complex,
but since we are creating thUML language ourselves, we don't need
to complicate things.
makes it harder for analysts to distinguish between important elements.
Fragments should be treated as they deserve to be treated—as less
important than real use cases.
something, I have chosen an icon that indicates a tiny element—a
dot. However, an icon that indicates a fragment would be more intuitive.
Figure 3 is an example of what I mean.
The Register Failures fragment (see Figure 2) has collapsed to a
dot and its name has tion, and l he dot represents an extension
fragment—the Register Failure fragment—let's call it “E.” E is he
dot would be expanded (by “clicking the dot”) to a new compartment
of the use case. We the example we only have one extension (Register
Failures) needed by Inspect Transaction e ometimes an extension
fragment is needed by several use cases (of type UC2). In these
cases g to all the n igure 3 also has an inclusion fragment—the
Validate User fragment. Inclusion fragments are here is an important
difference between inclusion fragments and extension fragments:
? An inclusion fragment will be “executed” by the use case instance
that also “executes” ? An extension fragment will be “executed”
by a use case other than the use case instance disappeared. The
semantics of the dot would be that while executing Conduct Transacwhen
reaching the extension point, something specified by the dot will
happen: an extension wilbe executed. The Inspect Transaction Failures
use case will use the extension to perform its responsibilities.
not part of the real use case Inspect Transaction Failures (called
UC2) that needs the extension. Since E is only needed by UC2 we
don't need to give it a name. Instead we attach it to UC2 by attaching
the dot to the use case symbol. However, it must be clear that the
use case (UC2) that needs the extension E doesn't <<extend>>
the other base use case Conduct Transaction (UC1) or the extension
E. Thus it would be completely wrong from a language point of view
to have use case UC2 <<extend>> UC1. Without the dot
or something similar we wouldn't be able to properly explain the
could name the new compartment “Extensions,” and use it to describe
the extensions needed bythe use case.
Failures. Thus in the extension compartment of Inspect Transaction
Failures we would describthe Register Failures use case. Since we
only have one extension, we didn't name it, but if there were multiple
extensions, we might name the dots.
the extension fragment must be named uniquely within the use-case
model. The dot representinthe extension fragment must be “free”
from one particular use case, but related (via dependencies—preferably
using the new stereotype <<need>> or something similar)use
cases that need it. An extension fragment of this kind is a kind
of classifier with an extensiocompartment.
not real use cases; they are reusable pieces of use-case descriptions
or “text objects.” Inclusion fragments are elements separate from
the use cases that include them, thus they are semanticallysimilar
to extension fragments needed by several real use cases.
the real use case (the one that includes it).
that needs it.
With UML terms, a fragment should be a classifier with a notation
that makes us think about tiny things—but now I go too deep for
the purpose of this paper. We also need a syntactic shortcut (syntactic
sugar) to attach a fragment to a concrete use case. We still need
to use fragments in a pragmatic way.
The Day After Tomorrow: The Future of Use Cases
Over the years there have been many ideas for improving use cases.
There are so many ideas and I don't know of them all, but I'll list
some of them below, and introduce some others. I can't refrain from
discussing the ones I am most excited about: making use cases code
modules through aspect-oriented programming and making use cases
run-time entities. Here are possible directions for the “future”
of use cases:
There are many ways to classify use cases. There are primary, secondary,
etc. use cases; there are business use cases, software use cases,
system use cases, etc.; business use cases are supporting, managerial
or operational10, … Stereotyping is a UML mechanism for classification
which would help developers in modeling of use cases.
- Clarify relationship between patterns and use cases
Many design patterns are “template” realizations of reusable use
cases. Such patterns are usually described using sequence diagrams
or collaboration diagrams. A pattern is a solution to a general
problem and it can be applied in different contexts. There is thus
an interesting relationship between a pattern and the generic, reusable
use case that specifies the problem. Clarifying this relationship
would be very helpful to developers.
- Using use cases within Human Computer Interaction (HCI)
HCI is a science. There is a way of designing a user experience
by understanding the user community, its habits, and its metaphors.
I was introduced to this technology by working with companies that
were developing large commercial Web sites for huge user communities.
Use cases would be an important concept to integrate software development
and HCI approaches.
- Cost estimations based on use cases
In 1994 Magnus Christerson lead Gustaf Karner's master's thesis11,
which resulted in a paper on project estimations based on use-case
points (derived from function points). To my knowledge this is still
an interesting paper. With all the experience we have today about
use cases and project estimations, we should be able to modernize
This is a huge topic. Reuse of business software should start from
understanding its use cases—both the use cases of the business,
and the use cases of the software to be used. This is the depth
of the Software Reuse book12 that I wrote with Martin Griss and
Patrik Jonsson back in 1994-97. It is more relevant than ever today
when a company's IT support is built by integrating enterprise applications,
whether these are legacy systems, packaged solutions, new applications,
or Web services. Further discussion can be found in my RUC 2002
talk “Closing The Gap: Business Driven Enterprise Application Integration.”
(I would be happy to send this to Rational employees.)
Making Use-Case Scenarios First-Class Citizens
It would be helpful to be able to identify and enumerate use-case
scenarios, and to show dependencies between these scenarios. Recall
that a scenario is a use-case instance that we choose to model.
This is probably more of a process issue than a language issue.
There are probably many kinds of dependencies.
Each project iteration is driven by a number of use-case scenarios.
Usually a use case is not completed within a single iteration, but
is worked on over several iterations. I would like to be able to
show how iterations are made up of scenarios, how a scenario grows
over several iterations, and how several different scenarios over
several iterations together make up a complete use case. You should
be able to show, for instance, that you may have to develop less
important scenarios first just to be able to develop more important
instances later. As a concrete example, you may need to first develop
a use-case scenario that allows a telephone system operator to make
a subscriber a valid user, before that subscriber can make any telephone
Test Case Dependencies
There are other reasons for dependencies between scenarios. One
is for testing. Integration testing is built up test case by test
case in very similar way to how iterations are built up.
We would be able to trace use-case scenarios to test cases. A good
use-case scenario is a good test case. The relationship between
a use-case approach and a test-first approach would become more
Use Cases and Aspect-Oriented Programming
One of the most exciting “new” movements today is Aspect-Oriented
Programming (AOP). AOP was the buzzword of the year at OOPSLA. And
for very good reasons. This article cannot get into any depth about
AOP. However, I can't refrain from giving some hints why AOP will
make the future of use cases fantastic. The whole idea with extension
use cases, that is to add behavior to an existing system without
changing it, is very similar to the whole idea of aspects. Use-case
realizations are implemented as aspects. Extension use cases will
be realized as aspects. Extension points are semantically similar
to join points.
When using the RUP, within each iteration we specify use cases,
we design them, and we test them. Between design and test we must
disrupt the use-case flow in order to design, code and test the
components that together realize the use cases. Using AOP will simplify
this: we'll go directly from use-case design to use-case programming
and then to use-case test. The work on components will be supported
by our programming environment (an AOPL = an OOPL + aspects). Thus
AOP allows us to seamlessly implement use cases.
Neither use-case driven development, nor aspect-oriented programming
are silver bullets. They represent two best practices only. However,
I believe that integrating them will dramatically improve the way
software will be developed.
Making Use Cases Run-Time Entities
The most exciting future of use cases is that they will also have
counterparts in the run-time environment. Being able to identify
executing use cases (use-case instances, in fact) in the operating
system can help us with many important features as discussed in
my 1985 thesis13, which had a semantic construct representing a
use-case instance. A use-case instance was created by an external
event, it lived during the whole interaction with the user (e.g.,
during the telephone call), and it tracked all the objects that
participated in the use-case instance. With such a construct, we
could change installed software much more incrementally—one use
case instance at a time. The software system could be restarted
in much smaller steps, in most cases by restarting only the use-case
instance that was broken. And, we could simplify the programming
of use cases. With AOP we may achieve parts of this. It seems as
we will at the least achieve use-case oriented programming. ?
Use cases have now been around for more than 15 years. We can move
them a step forward by cleaning up some minor defects: by separating
use cases and fragments. This can be done tomorrow.
The day after tomorrow, there are many interesting ideas to expand
on use cases. Many of the ideas we have are just marginal improvements.
However, two of the ideas are dramatic enhancements: making use
cases code modules and making them executable run-time entities.
Until then, enjoy use cases as they are today!
I would like to thank Kurt Bittner, Gunnar Overgaard, Paul Szymkowiak
for their feedback on an early version of the paper. Thanks to Catherine
Southwood for editing the paper. 15 ? 2002 Rational Software 11/26/2002