Define Variation Point and give two examples.
Effective reuse requires assets that can be altered to fit more then one circumstance.
Assets that can adjust to multiple usage contexts, are more valuable then ones that only fit
one tightly defined use. The ways in which a parametrizable, or tailorable asset can be
altered to fit multiple contexts are called its variation points.
A reusable asset that stores data can vary in which type of persistence it uses: RDBMS,
flat files, or XML files. The persistence type is its variation point.
A reusable asset that accepts user logins can vary in the authentication mechanisms it
uses: Operating System Account Authentication (supplied by the OS, e.g. Windows
Authentication) or Custom Authentication (Custom code which stores user account
information and authenticates against it. The type of authentication is the variation point.
Define Variant and give two examples.
The ways in which as asset varies at its variation point, the possible values for a variation
point are its variants. In the examples above: the variants on the persistence variation
point are RDBMS, flat files, and XML files. The variations on the authentication
variation point are OS Account Authentication and Custom Authentication.
Define “Processing Immaturity”.
I assume this was a ‘typo’, and this should have been Process Immaturity. The process
(rules, standards, methods, tools, etc,) that an organization uses to build software controls
how we build software (process), rather then what we build (design), or why we build it
(requirements). When our processes do not control all phases of the development
(requirements and design and test and deployment and maintenance and Configuration
management, etc.) or the process does not completely and effectively control all of the
phases the process is immature. See CMM and CMMi for more information.
What is persistence?
Data that exists in the system, or is produced by the system while it is running, and is still
available to the system after the system has been shut down and then restarted, persists,
and is therefore persistence. Examples: flat files, databases, XML files, etc.
How to resolve traceability and reconstruction problems?
I’m not sure what this question is asking. Traceability is a problem in all systems. The
ability to tell whether a requirement is represented in the design requires a tracing of each
requirements into the design features that satisfy the requirements. Reuse benefits from
traceability in additional ways. When we can trace requirements to designs and
implementations, we can search for reusable implementation assets by first searching for
the requirements we want to satisfy, and then using requirements to trace to the
respective implementation of solutions to those requirements.
Often, a development organization does not keep its requirements, design,
implementation, and traceability among these different life cycle products up to date (e.g.
a change is made in the code, implying a design change but the design doc is not
updated). This means that maintainers can not trust that the design represents the overall
structure of the implementation, and therefore the design is no longer a useful
maintenance tool. Reconstruction. The design and the design decisions behind it must
then be reconstructed. The two solutions are to keep all SDLC artifacts in synch
(obviously), or use reverse engineering (see below).
How well does COTS use work as a form of Software Reuse?
When you reuse a COTS product, you are reusing the software built by the software
developers at the COTS vendor. COTS is a great way to reuse, and besides the most
popular COTS products (RDBMS, Web Server, etc) there are many more specialized
reusable assets available as COTS products (see ComponentSource.com)
What is full round trip engineering?
Forward engineering is moving forward in the SDLC (Software Development Life
Cycle). From requirements to design to implementation. Reverse engineering is moving
backwards, e.g. taking an implementation and producing the design implied by that
implementation. When a changing a system for which complete design, requirements,
and traceability records/artifacts/documents don’t exist, one reverse engineers from the
implementation to the design, alters the design to meet the new requirements, and then
forward engineers the new system. Reverse engineering, altering the design or
requirements, then forward engineering a new solution is full round trip engineering.
With the newly updated design and traceability, the next time changes are required of the
system, the effort will be much lower.
What is a Variation Point ?
See above
How does a variant differ from a variation point?
See above
In what two engineering domains did graphical specification s/code generation first
succeed?
GUI and Database applications
What are the five steps of graphical specification code generation?
create project (optional)
draw
annotate (optional in very rare cases)
generate (sometime done automatically every time a draw or annotate change occurs)
complete (optional in very rare cases)
What does it (graphically spec based code generation) reuse?
The code generator must store, understand, or construct code from the graphics. To do
that, it must have some basis on which to write that code. In most cases a set of code
“snippets” (small grain reusable assets) which are categorized into variation points and
their respective variants are used as a basis for that code generation. Therefore, its partly
code reuse, and partly code generation. IN other cases, the generator actually produces
new code from variants of generic designs. In that case the design are being reused. It’s
usually a combination of reusable snippets, or generic programming templates combined
with some code generation.
Discuss some ways in which a balance might be struck between excessive formalism
and excessive autonomy?
That is a topic for a another coursed. We note the problem in this course, and present a
possible solution (Software Factories), but we can not present a full discussion of it here.
What is specification based code generation?
Generating code (a very low level abstraction) from a specification, or description of that
code (a higher level abstraction).
Give an example?
The drawing of a GUI in a UI editor generated a pictorial or graphical specification of the
actual code that will then draw that UI on the screen of a computer. A GUI editor is not a
picture drawing program.
Explain the difference between accidental and intentional complexity.
That should be accidental and essential complexity. Essential complexity is what comes
with the problem to be solved. The accidental complexity is what is added by the solution
being used to solve the problem.
With set requirements which form of complexity can be altered by the software
developer?
The accidental complexity.
How can the level of complexity be altered by the developer?
By either reducing the requirements (the essential complexity) or by finding a better
solution (reducing accidental complexity).
What are the deficiencies of the current software development paradigm?
We have not yet learned to assemble (ed. systems from) reusable components on a
commercially significant scale.
Software is still produced almost entirely from scratch.
Software is still too expensive, too low in quality, too difficult to price and schedule, and
we can’t build all of the systems we need to build with current resources.
What is the abstraction gap and how can it be narrowed?
The space between the design and the code, or between a 4GL language and a 3GL
implementation is a abstraction gap. Making the distance between the two levels of
abstraction reduced the gap. This must be balanced. If the gap is too small, there is no
advantage in using the abstraction. It eh gap is too large, its very difficult to bridege the
gap between the two either by generation or translation.
Describe some technique to reduce brittleness.
Wait for later chapters
Describe some technique to reduce fatigue.
Wait for later chapters
It seems that software libraries benefit from a wide scope of use because a larger
user base leads to improved quality.
However, more exposure of a software library has, the more prone it is to having
security holes found, i.e. MS Windows.
Where is the balance? A library that’s too prolific draws too much attention from
malicious hackers.
In terms of asset reuse, What advantages does the domain-specific code generation
have over traditional, OO source code based reuse? Disadvantages?
OO is not a different form of reuse from domain specific. OO is simply a modularization
technique. Object oriented, or source code based reuse can also be domain specific, and
in most cases is where it’s succeeded. Domain specific reusable anything is delaing with
a smaller scope, less complexity, smaller abstraction gaps; with all the advantages of
those traits.
Describe some technique to reduce brittleness.
See above.