- (5 points each, 30 points total)
Define each of the following terms, as used in software
engineering.
- Module
A software fragment; a provider of
computational resources or services; a collection
of routines, data, objects;
hides a secret; communicates through well-defined
interfaces;
- Robustness (the software quality)
The quality of behaving reasonably in unanticipated
circumstances.
- Acceptance Test Plan
A plan for evaluating an implemented software
system to determine whether it meets all the requirements
and constraints specified in a Requirements Specification
Document.
- Low coupling
High independence between modules; modules do
not depend on each other heavily.
- The USES relationship
Module a USES module b if and only if a
only works correctly when b works correctly.
- Perfective Maintenance
Changing the software to improve some of its
qualities; adding new functions to software.
- (12 points)
One type of separation of concerns
that is important in Software Engineering
is modularity: dividing the software into modules,
based on functionality,
information hiding, and concern for reusability.
Describe another type of separation of concerns that
is important in Software Engineering. Give an example of how
this type of separation of concerns might apply to a software system
such as Volly, and why it might lead to a better software product.
A wide range of answers were accepted for this problem.
Scoring was based on four points for describing another type
of separation of concerns; four points for giving an example;
and four points for writing why this leads to better software.
If your sheet is marked with three numbers, this indicates your
score for each of the three parts.
- (12 points)
Determine the words (in five cases) or short phrase
(in one case) that best match
(a) through (f) in the following paragraph, and write
them below.
The set of services that each module provides to its
__(a)__
(i.e. the purpose of the module as it relates
to other modules) is called its
__(b)__ .
The corresponding services are said to be
__(c)__
by the module and
__(d)__
by its
__(a)__
The way these services are accomplished by the module
is called the module's
__(e)__ .
A clear distinction between the
__(b)__
of a module and its
__(e)__
is a key aspect of good design, because it supports the
__(f)__ .
See p. 81 of Ghezzi.
- clients
- interface
- exported
- imported
- implementation
- separation of concerns; we also accepted
anticipation of change and information hiding.
- (4 points)
Draw a line from each process model in the left column to
the correct corresponding characterization in the right column.
spiral model --- risk driven
transformation-based --- specification driven
waterfall --- document driven
evolutionary --- increment driven
- (12 points)
Draw and label
a diagram representing the ``spiral'' software
process model.
See page 381.
Grading rubric:
Upper left quadrant: 3 pts. for mentioning at least two of
``objectives,'' ``alternatives,'' ``constraints.''
Upper right quadrant: 2 pts. for ``Evaluate alternatives and
identify and resolve risks.'' 1 pt. for either
``risk analysis'' or ``prototype.''
Lower right quadrant: 2 pts. for ``Develop, verify.''
1 pt. for any of ``Concept of operation,'' ``requirements,''
``design,'' ``test,'' ``code.''
Lower left quadrant: 3 pts. for ``plan.''
1 pt. for drawing a spiral.
This adds up to 13, but the max was 12.
- (12 points)
Write, using English prose,
a brief descriptive specification for the functionality
of a word processor's spell-checker.
It flags or lists words that appear to be incorrectly spelled.
It may also list proposed correct spellings of these words.
Write, using English prose,
a brief operational specification of a spell-checker.
The spell-checker program has a list of words, called a
``dictionary.'' It also has an algorithm that ``normalizes''
a word: converts it to lower case, makes it singular
(e.g. changes
``cats'' to ``cat'' and ``guppies'' to ``guppy'')
(irregularly formed plurals (e.g. ``mice'') will be entered
in the dictionary), removes verb tense endings (e.g.
``eats'' to ``eat'', ``sleeping'' to ``sleep''), and
removes ``'s'' for possesive. Some words are identified
as ``to be skipped'': those that have numbers in them or are in
all capital letters. Each word in the document that is not
``to be skipped'' is normalized, then the spell-checker
determines if the word is in the dictionary. If it is not,
it is flagged as potentially misspelled.
- (3 points) Which of the following is not
part of the evolutionary process model?
(Choose one.)
- Define an acceptance test plan in the requirements document.
- Measure the added value to the user in all critical dimensions.
- Adjust both the design and the objectives based on observed
realities.
- Deliver something to the real user.
- (3 points) In object oriented design, there is a single
type of module, which is (choose one)
- the ADT module. (see p. 117)
- the interface.
- the extends module.
- the USES module.
- the constant module.
- (3 points) The first item on Barry Boehm's list of Top 10
software risk items is (choose one)
- personnel shortfalls.
- Y2K.
- low cohesion.
- incompatibility between different version of Java.
- null pointer exceptions.
- (3 points) According to the textbook, when a computer
program behaves according to its specification, it exhibits
(choose one)
- correctness.
- understandability.
- evolvability.
- repairability.
- All of the above.
- (3 points) In the case of highly critical systems, what
term is used to denote the absence of undesirable behaviors
that can cause system hazards?
(Choose one.)
- Safety. (see p. 38)
- Reliability.
- Riskiness.
- Adaptability.
- Mission critical.
- (3 points) A module's ``secret'' is
(choose one)
- its changeable, hidden information. (see p. 84)
- its private data members.
- in the case of Java not really a secret because
it is discoverable by a ``decompiler'' program.
- either a trade secret, or a patented process.
- selected to maximize cohesion and minimize coupling.