Design of a hyper-environment for tracing object-oriented requirements

 Change is inevitable and unending in developing large, complex systems. Changes to requirements arise not only from changes in the social context of the system, but also from improved understanding of constraints and tradeoffs as system development proceeds. How to trace software requirements is the problem addressed by this thesis. We present a solution for requirements tracing in the context of object-oriented software development. Our solution consists of a traceability model and a tool to automate the tracing. TOOR, the tool to implement the model, uses a project specification written in FOOPS, a general purpose object-oriented language with specification capabilities, to set up the environment in which a project is carried out. The project specification defines the trace units and traces as objects and relations, respectively. The evolution of objects from requirements sources to requirements to design to code, and generally to any object taking part in the process is dealt with in a uniform way in TOOR: classes are declared for each kind of object we wish to control, and relations are defined between them. TOOR uses regular expressions to provide a selective tracing mode : the actual configuration of objects and relations is considered as a text and regular expressions are used to retrieve parts of the configuration matching the pattern described by them. TOOR enhances the flexibility of regular expressions by extending the pattern matching procedure by providing different ways of specifying how an object or relation is to be matched. Other modes of tracing in TOOR are the interactive tracing through modules and the non-guided tracing through several browsing mechanisms. TOOR modules are used to structure projects by providing hierarchical scopes for objects used in a project development. The tracing mechanisms of TOOR can use the project structure to order searches or to provide boundaries for searching. Browsing objects provides additional flexibility in situations where little information of what has to be traced is possessed and hyper-media features address the need to re-interpret data usually encoded in different formats. The user-definable features of a project specification provides much of the flexibility necessary for effective use of a software tracing tool. Also, the integration of regular expression tracing with other forms of tracing such as browsing and interactive tracing makes TOOK an extremely versatile tool. The user can select the more appropriate form of tracing depending on context and can switch from one form to another as convenient.

[1]  J. Goguen,et al.  Techniques for Requirements Elicitation 1 , 1993 .

[2]  Alan M. Davis,et al.  Operational prototyping: a new development approach , 1992, IEEE Software.

[3]  Hartmut Ehrig,et al.  On the Relationship Between Algebraic Module Specifications and Program Modules , 1991, TAPSOFT, Vol.2.

[4]  Alfred V. Aho,et al.  The Design and Analysis of Computer Algorithms , 1974 .

[5]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[6]  Joseph A. Goguen,et al.  An Object-Oriented Tool for Tracing Requirements , 1996, IEEE Softw..

[7]  John Mylopoulos,et al.  On formal requirements modeling languages: RML revisited , 1994, Proceedings of 16th International Conference on Software Engineering.

[8]  Rolf Pfeifer,et al.  Situated Software Design , 1993, SEKE.

[9]  W. H. Mac Williams Keynote address , 2006, AIEE-IRE '51.

[10]  Alan M. Davis,et al.  A Strategy for Comparing Alternative Software Development Life Cycle Models , 1988, IEEE Trans. Software Eng..

[11]  Janusz A. Brzozowski,et al.  Derivatives of Regular Expressions , 1964, JACM.

[12]  David Lorge Parnas A technique for software module specification with examples , 1983, CACM.

[13]  Janis A. Bubenko,et al.  Theories underlying requirements engineering: an overview of NATURE at Genesis , 1993, [1993] Proceedings of the IEEE International Symposium on Requirements Engineering.

[14]  Simon McGinnes,et al.  CASE support for collaborative modelling: re-engineering conceptual modelling techniques to exploit the potential of CASE tools , 1994, Softw. Eng. J..

[15]  John A. McDermid,et al.  Learning from IPSE's mistakes , 1992, IEEE Software.

[16]  Joseph A. Goguen,et al.  Putting Theories Together to Make Specifications , 1977, IJCAI.

[17]  Mack W. Alford,et al.  Software requirements in the 80's , 1980, ACM '80.

[18]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[19]  Joseph A. Goguen,et al.  The Dry and the Wet , 1992, ISCO.

[20]  O. Gotel,et al.  Contribution Structures , 1995 .

[21]  Anthony Finkelstein,et al.  Viewpoint Oriented Software Development: Mehtods and Viewpoints in Requirements Engineering , 1989, Algebraic Methods.

[22]  Alan M. Davis,et al.  Impacts of life cycle models on software configuration management , 1991, CACM.

[23]  Rudolf Lauber,et al.  Development Support Systems , 1982, Computer.

[24]  J. Murray The Oxford English Dictionary , 1913 .

[25]  Alan M. Davis,et al.  Requirements language processing for the effective testing of real-time systems , 1978 .

[26]  Mack W. Alford SREM at the Age of Eight; The Distributed Computing Design System , 1985, Computer.

[27]  Marina Jirotka Requirements Engineering as the Reconciliation of Social and Technical Issues , 1994 .

[28]  Orlena Cara Zena Gotel,et al.  Contribution structures for requirements traceability , 1995 .

[29]  Joseph A. Goguen,et al.  Formality and Informality in Requirements Engineering , 1996, ICRE.

[30]  Thomas E. Bell,et al.  An Extendable Approach to Computer-Aided Software Requirements Engineering , 1976, IEEE Transactions on Software Engineering.

[31]  Anne Brüggemann-Klein Regular Expressions into Finite Automata , 1993, Theor. Comput. Sci..

[32]  David Lorge Parnas,et al.  On a 'Buzzword': Hierarchical Structure , 2001, IFIP Congress.

[33]  John A. McDermid,et al.  On integration and reuse in a software development environment , 1991 .

[34]  Charles R. Vick,et al.  The Software Development System , 1976, IEEE Transactions on Software Engineering.

[35]  Joseph A. Goguen,et al.  HYPERPROGRAMMING: A Formal Approach to Software Environments , 1990 .

[36]  Bashar Nuseibeh,et al.  Managing inconsistencies in an evolving specification , 1995, Proceedings of 1995 IEEE International Symposium on Requirements Engineering (RE'95).

[37]  José Meseguer,et al.  Unifying Functional, Object-Oriented and Relational Programming with Logical Semantics , 1987, Research Directions in Object-Oriented Programming.

[38]  Alan M. Davis,et al.  Software Requirements: Objects, Functions and States , 1993 .

[39]  Joseph A. Goguen,et al.  The Semantics of CLEAR, A Specification Language , 1979, Abstract Software Specifications.

[40]  Matthias Jarke,et al.  Tool Integration in Evolving Information Systems Environments , 1994, IS/KI.

[41]  Bashar Nuseibeh,et al.  Software process modelling and technology , 1994 .

[42]  Joseph A. Goguen,et al.  Reusing and Interconnecting Software Components , 1986, Computer.

[43]  Kazuhisa Kawai,et al.  Idea processor and the KJ method , 1990 .

[44]  Gary Griffiths CASE in the third generation , 1994, Softw. Eng. J..

[45]  Valdis Berzins,et al.  CAPS as a requirements engineering tool , 1991, TRI-Ada '91.

[46]  Joseph A. Goguen,et al.  Parameterized Programming , 1984, IEEE Transactions on Software Engineering.

[47]  Barry W. Boehm,et al.  Verifying and Validating Software Requirements and Design Specifications , 1989, IEEE Software.

[48]  Margaret Hamilton,et al.  The functional life cycle model and its automation: USE.IT , 1983, J. Syst. Softw..

[49]  Razvan Diaconescu,et al.  Category-based Semantics for Equational and Constraint Logic Programming , 1994 .

[50]  Alfred V. Aho,et al.  Pattern Matching in Strings , 1980 .

[51]  Joseph A. Goguen,et al.  Principles of parameterized programming , 1989 .

[53]  Joseph A. Goguen,et al.  Parameterized programming and software architecture , 1996, Proceedings of Fourth IEEE International Conference on Software Reuse.

[54]  John A. McDermid,et al.  Requirements analysis: orthodoxy, fundamentalism and heresy , 1994 .

[55]  Mack W. Alford A Requirements Engineering Methodology for Real-Time Processing Requirements , 1977, IEEE Transactions on Software Engineering.

[56]  Dorothy A. Kuhn AUTOMATING SYSTEMS ENGINEERING , 1994 .

[57]  Ken Eason,et al.  Early Evaluation of the Organisational Implications of CSCW Systems , 1996 .

[58]  Olly Gotel,et al.  Revisiting requirements production , 1996, Softw. Eng. J..

[59]  M.M. Lehman,et al.  Programs, life cycles, and laws of software evolution , 1980, Proceedings of the IEEE.

[60]  Ralph Storer Practical program development using JSP , 1987 .

[61]  Daniel D. McCracken,et al.  Life cycle concept considered harmful , 1982, ACM SIGSOFT Softw. Eng. Notes.

[62]  Ellis Horowitz,et al.  SODOS: A software documentation support environment — Its definition , 1986, IEEE Transactions on Software Engineering.

[63]  Bashar Nuseibeh,et al.  Expressing the relationships between multiple views in requirements specification , 1993, ICSE '93.

[64]  Alan M. Davis,et al.  The Design of a Family of Application-Oriented Requirements Languages , 1982, Computer.

[65]  Tom Rodden,et al.  Presenting ethnography in the requirements process , 1995, Proceedings of 1995 IEEE International Symposium on Requirements Engineering (RE'95).

[66]  Robert A. Pierce,et al.  A Requirements Tracing Tool , 1978 .

[67]  C. W. Dawson,et al.  Towards more flexible management of software systems development using meta-models , 1995, Softw. Eng. J..

[68]  Luqi,et al.  A computer-aided prototyping system , 1988, IEEE Software.

[69]  Olly Gotel,et al.  An analysis of the requirements traceability problem , 1994, Proceedings of IEEE International Conference on Requirements Engineering.

[70]  Wes Sharrock,et al.  Occasioned practices in the work of software engineers , 1994 .

[71]  Hermann Kaindl,et al.  The missing link in requirements engineering , 1993, SOEN.

[72]  V. Glushkov THE ABSTRACT THEORY OF AUTOMATA , 1961 .

[73]  Gérard Berry,et al.  From Regular Expressions to Deterministic Automata , 1986, Theor. Comput. Sci..

[74]  Ellis Horowitz,et al.  SODOS: A software documentation support environment — Its use , 1985, IEEE Transactions on Software Engineering.

[75]  Steve Easterbrook Negotiation and the Role of the Requirements Specification 1 , 1993 .

[76]  Dov M. Gabbay,et al.  Inconsistency Handling in Multi-Perspective Specifications , 1993, ESEC.

[77]  Stuart I. Feldman,et al.  Make — a program for maintaining computer programs , 1979, Softw. Pract. Exp..

[78]  M. Dorfman,et al.  ARTS - An automated requirements traceability system , 1981 .

[79]  K. Futami,et al.  Functional Specification of Call Processing by State Transition Diagram , 1971 .

[80]  Barry W. Boehm,et al.  A spiral model of software development and enhancement , 1986, Computer.