ftp.umcs.maine.edu/2015-02-07.ftp.umcs.maine.edu.tar/ftp.umcs.maine.edu/pub/WISR/wisr5/proceedings/ascii/hufnagel.ascii

Text File | 1993-05-29 | 18KB | 376 lines

Formally Specified Object-Oriented Approach to Reuse

Steve Hufnagel

The University of Texas at Arlington
Computer Science Engineering Department
Arlington, Texas  76019-0015
Tel: [phone], fax: [phone]
E-mail: [e-mail]


                      Abstract

Our work targets the establishment of a knowledge base - an
integrated software construction framework of software tools to
build, maintain, and reuse quality software. The key innovative
concept is our meta-linguistic object-oriented approach with which
to formally specify, archive, and retrieve reusable components.
A domain specific thesaurus is used to translate amongst application
domains. The main design goal is to maintain overall conceptual
integrity and simplicity, while integrating diverse technologies
into a unified environment. Mathematical and linguistic formalisms,
engineering principles and problem solving techniques, in addition
to methods and approaches from artificial intelligence, computer
science, and communications, are the foundation of this work.

Keywords:  formal specifications, object-oriented, Z, Object-Z, reuse,
       environment

Workshop Goals:  learning; networking; identifying research directions

Working Groups:  Reuse and formal methods; Reuse and OO methods; Domain
         analysis/engineering; Design guidelines for reuse -
         general, Ada, and/or C++; Useful and collectible metrics;
         Tools and environments; Education


1  Background

Reuse is the ``Holy Grail'' and nemesis of software developers.


1.1  The Need

Most companies are dedicated to gaining a competitive edge in
meeting customer needs by getting to market more quickly with
appropriate high-quality products at lower development costs. The
international telecommunications industry is perhaps the most
competitive of modern times. Telecommunication software must be
easy to maintain, flexible in operation, and quickly enhanced.
There is an increased demand for graphical user interfaces, a
need for greater portability amongst development and application
platforms, reliability in support of increasingly critical
wide-spread applications, and an increased use of distributed
multi-user and multi-version environments.


2  Reuse environment

Our research objective is directed toward creating an environment
in which software components are developed, organized, and made
available for reuse. Domain knowledge, proper component description,
tool support, and a skilled staff are needed [Schaefer91]. This
requires integration of the best of current day technologies into a
framework that is intended to evolve and adapt to new and improved
technologies. The most important design goal is to maintain conceptual
integrity and interoperability amongst software tools [Brooks87] so
that the environment is powerful, yet intuitively simple to use. The
key concept of our work is a meta-linguistic object-oriented approach
to formally specifying, archiving, and retrieving reusable
domain-specific components.  Domain analysis of general areas to
identify primitive reusable components and object-oriented
analysis of user requirements is becoming part of the software
development lifecycle [Coad91, Prieto-Diaz91]. The determination
and management of software abstractions, specifications, and
indexing of class libraries and object components are critical
strategic tasks in building Domain Engineering Environments
(DEE's). See Figure 1. This information must be distributed and
visible to management as well as to design teams. Corporate
training and software quality control are important ingredients
in a software reuse environment.

    Figure 1: Domain Engineering Environment (DEE)
    Figure 2: Application Engineering Environment (AEE)
    Figure 3: Meta-Linguistic Framework
    Figure 4: Intelligent Network-Based Software Development
          Environment (INBSDE)

Future CASE products will contain extensive libraries and will
become programming language transparent to designers. Intelligent
tools, utilizing artificial intelligence technology, will provide
easy-to-use and easy-to-learn graphical user interfaces to these
libraries [Harmon90].

The users of a reuse environment are the domain analysts who
specify reusable components; implementers who build the
components; application designers who use the components to build
systems; managers who schedule and do strategic planning; and
customers who need system documentation.


2.1  Application engineering environment

We believe that domain-specific Application Engineering
Environments (AEEs) for reuse, using meta-linguistic techniques
for indexing, will become application designers' tool boxes. See
Figure 2. These will eventually be standardized and integrated
into operating systems, as UNIX pipes are used today.

A steady evolution of domain-specific AEE's will eventually
produce generic application engineering environments. We envision
AEE's being used by geographically distributed teams of software
developers working on different parts of the same large project.
Configuration management and version control are automatically
maintained by the AEE. A target software system is assembled from
a combination of reusable components and new components provided
by the software engineers [Ramamoorthy91].

The AEE concept proposed in this paper provides access to
libraries appropriate for a particular domain. An AEE is a
software management tool, optimized to take advantage of the
semantics of the application domain. It provides the user
interface for analysis and design, requirements, textual and/or
graphical specifications [Coad91] of the object model, dynamic
model, and functional model of the system, and a rapid prototype
animator and test scenario simulator. It must present a clear,
complete, correct, concise, and consistent representation of the
software products contained within. An AEE should be easy to use
and flexible.


2.2  Libraries/Repository

The success of the environment in large part depends upon
capture, structuring, and delivery of knowledge in forms readily
usable by the individual engineer and development project as a
whole. The repository will contain both generic and
domain-specific components and subsystems, as well as the
information required to produce appropriate documentation
concerning each component. Generic libraries span application
areas and may include traditional algorithms for data structure
manipulation, mathematical functions, and components. These
components, although derived in a domain-specific context, may be
more widely applicable than the original developer imagined.
Generic algorithms often have domain-specific counterparts with
names and attributes peculiar to a given domain. The
correspondence between generic forms and domain-specific
renderings of the same or closely related logic must be captured
to make the identification of new instances of software reuse
simple and semantically correct for the specialists wo The
conceptual framework for such capabilities must include
provisions for capturing syntactic structures, semantic
information, and must support a form of translation through a
combination of equivalence rules, grammatical mappings, and
analogical relations. We call this concept the "meta-linguistic
framework."


2.3  Meta-linguistic approach

Among the central problems in computer-aided software
engineering (CASE) systems are lack of provision for requirements
understanding and related problems of traceability, making
inferences, and controlling those inferences. To address these
problems, a meta-linguistic method for controlling inferences is
proposed that has positive effects on ease-of-use, correctness,
information archiving and retrieval, scenario applications to
view analysis, requirements traceability, and tracking of goals
and plans.

Meta-linguistic means that there is a common domain-independent
virtual specification of system components. See Figure 3. This
meta-specification, plus one or more domain thesauri, maps
amongst domains and provides the mechanism for archiving and
retrieving reusable components. The basis of our meta-linguistic
approach is conceptual dependency theory [Schank88] combined with
scenario-based processing of requirements [Wang91].

An example is requirements analysis. An analysis program
interacts with a user and maps requirements into
language-independent formally-specified structures (Fig. 1). A
template-based data dictionary management program makes
inferences from input conceptual structures and determines if
reusable components already exist (Fig. 2). A generator maps
conceptual structures into documentation: requirements, graphical
specifications and designs (e.g., state transition, entity-relation,
and flow diagrams) and a software language (Fig. 3). Together the
programs will function as a software construction workbench and
reuse inference system. See Figure 4.

Meta-linguistic representation has a language-free deep
conceptual base (i.e., conceptual dependency) [Schank88]. The
conceptual analysis of a system's requirements, specifications,
and design and the nature of their conceptual base, from both
theoretical and practical standpoints, must be developed. The
various types of inferences, that can be made during and after
the conceptual analysis, must be defined. A functioning AEE is
being built to prototype these inference tasks.

A result of the meta-linguistic approach is an environment that
may be said to function intelligently and is self tutoring. Since
natural language may be assumed to have an underlying conceptual
structure, the environment's object database structure
(conceptual dependencies) must be represented in a manner
concomitant with the human needs for using it.


2.4  Formal methods

A formal specification is valuable because it provides: n a
consistent form for the expression of specifications, n an
axiomatic mechanism to support expression of relations among
specifications, n a proof theory which supports mathematical
analysis of specifications.  Formal methods have largely been
used for life-critical and high reliability systems. There are a
number of formal specifications in use, among them Z ("Zed"), VDM
(Vienna Development Method), and LOTOS (Language of Temporal
Ordering Specification), which is the CCITT standard
specification language devised for telecommunications systems.

Formal specifications allow desirable characteristics to be proved
and inconsistencies to be uncovered during analysis.  Beyond providing
a mechanism for expressing and proving system attributes, formal
methods have been found to be more compact than conventional natural
language specifications by as much as an order of magnitude. Further,
there are multiple instances in which the use of such methods have
saved money, improved understandability, and supported aggressive
schedule constraints [Hall90].

The integrated use of the formal specification may include
entity-relationship, dataflow, and state transition diagrams for
components and subsystems, as well as inheritance hierarchies
when object-oriented approaches are used. This provides a
powerful means to visualize, animate, and reason about the static
structure and dynamic behavior of a system prior to the
investment of time and funds to create the envisioned system.


2.5  Object-oriented Technology

Object-oriented technology is being promoted as a significant way
to achieve software reusability. In discussing Interactive
Development Environment's object-oriented structured design
(OOSD), Wasserman encourages users to follow principles of
information hiding, attention to reuse through the use of
inheritance and generics (templates), and a spiral model of
software development [Wasserman90]. Brooks holds out hope for
object-oriented technology as the way to achieve software
reusability [Brooks87]. Cox declares object-oriented as an
objective rather than a technology. He states that
object-oriented is the key element to the creation of a
standard-parts marketplace with pluggable software components
assembled into higher-level solutions [Cox90]. It is important to
reiterate what many experts have stated: while continually
evaluating new methodologies, the method, procedure, or technique
needs to be appropriate for a particular system, and the
discipline imposed by a methodo!  logy must be consistently
applied 4.4 Other Methodologies Object-oriented methods, while
obviously powerful, are not ends in themselves. There are
numerous examples of systems which either do not readily admit an
object-oriented view or are equally well represented by other
approaches. We envision a system which is methodology supportive,
not methodology prescriptive. As such, other approaches which
have been found to be useful in the past will be supported,
including: n traditional functional decomposition techniques,
such as structured design techniques of Yourdon or the successive
refinement technique pioneered by Wirth, n data structured
methods exemplified by Warnier-Orr and Jackson, n hybrid
modelling techniques such as Petri nets, which have been
successfully applied to real-time applications, neural networks,
communications, and large-scale production rule systems.

The goal of the environment we are pursuing is to empower the
engineers who use this system with integrated capabilities not
previously at their disposal. To preclude the use of methods that
have proved valuable to visualize systems in the past would be a
disservice and counterproductive to users.


3  Prototype activities

 We are creating a conceptual architecture for the environment we
have described in this paper. Using telecommunications examples,
we are building prototypes of object-oriented database platforms,
user interfaces, and inference engines. These prototyped concepts
will evolve as we gain further experience in the technologies and
a deeper understanding of the abstract aspects of the environment
we are developing.


4  Position

The competitive edge in systems development comes from
easy-to-use corporate-wide sharing of standardized software
components and the automatic management of documentation and
configuration complexity of large systems. We believe the
approach presented in this paper provides the framework for an
intelligent, network-based, distributed software development
environment, that supports and encourages building reusable
software components.


5  Comparison

Biggerstaff points out that reuse is not the silver bullet of
success and is not merely the task of gathering up components and
casually assembling a library. We cannot have reuse without
changing our process. He indicates that the key factors that make
reuse successful, are: (1) narrow, well understood, slowly
changing domains; (2) inter-component standards that enable
interconnectability of components; (3) economies of scale in the
market where the same kind of software is being built over and
over again; (4) economies of scale in technologies: big
components produce larger payoff than small components because
the interconnection and defect removal costs are lower; and (5)
infrastructure support - tools that enforce the process are
critical to the success of reuse [Biggerstaff91].


6  Biography

Stephen P. Hufnagel is Assistant Professor, Computer Science
Engineering Department, The University of Texas at Arlington, and
a member of the Software Engineering Center for Telecommunications.
He works as a consultant with NEC America, Texas Instruments, and
Electrospace Inc.  His research interests include telecommunication
software, requirements analysis, formal specifications, the object
paradigm, and software construction methodologies. He received a
B.A. in psychology and mathematics and a Ph.D. in computer science
from The University of Texas at Austin.


References

[1]  Biggerstaff, T. J., Panel: "Software Reuse: Is it Delivering?,"
     Proceedings, 13th ICSE, Austin, Texas, May 1991, pp. 52-61.

[2]  Brooks, F. P., "No silver bullet, essence and accidents of software
     engineering," IEEE Computer, April 1987, pp. 14.

[3]  Coad, Peter, and Yourdon, Ed, Object-Oriented Analysis, Prentice Hall,
     Englewood Cliffs, New Jersey, second edition, 1991.

[4]  Cox, Brad J., "There is a Silver Bullet," BYTE, October 1990, pp. 209-218.

[5]  Hall, Anthony, "Seven Myths of Formal Methods," IEEE Software,
     September 1990.

[6]  Harmon, Paul, and Sawyer, Brian, The ObjectVision Manual: A Graphical
     Programming Tool for Object-Oriented Applications, Addison Wesley,
     Reading, Massachusetts, 1990.

[7]  Prieto-Diaz, R., and Arango, G., Domain Analysis and Software Systems
     Modeling Tutorial, IEEE Computer Society, 1991.

[8]  Ramamoorthy, C.V., Miguel, Luis, and Shim, Young-Chul, "On Issues in
     Software Engineering and Artificial Intelligence," International Journal
     of Software Engineering and Knowledge Engineering, Vol. 1, No. 1, 1991,
     pp. 9-20.

[9]  Schaefer, W., Panel: "Software Reuse: Is it Delivering?," Proceedings,
     13th ICSE, Austin, Texas, May 1991, pp. 52-61.

[10] Schank, R. C., and Ram, A., "Question-driven parsing - a new approach to
     natural language understanding," Journal of Japanese Society for
     Artificial Intelligence, Vol. 3, No. 3, 1988, pp. 260-269.

[11] Wang, Wei, and Hufnagel, Stephen, "An Application-Specific, Scenario-
     Driven, Object-Oriented Software Development Technique (SSOOSDT)," in
     preparation for submittal to IEEE Transactions on Software Engineering.

[12] Wasserman, Anthony I., and Pircher, Peter A., "Customizing Object-Oriented
     Structured Design for C++," Technical Paper, Interactive Development
     Environments, Inc., San Francisco, California, December 1990.