Rigorous Object-Oriented Analysis

The Rigorous Object-Oriented Analysis (ROOA) method provides a systematic development process which takes a set of informal requirements and produces a formal object-oriented analysis model. The model, which is expressed in LOTOS, integrates the static, dynamic and functional aspects of a problem and acts as a requirements specification. As LOTOS specifications can be executed symbolically, rapid prototyping can be used to check the conformance of the specification against the requirements and to detect inconsistencies, omissions or ambiguities so that feedback can be given to the requirements capture process.

[1]  Alan M. Davis.  A taxonomy for the early stages of the software development life cycle , 1988, J. Syst. Softw..

[2]  Alan M. Davis.  Rapid prototyping using executable requirements specifications , 1982 .

[3]  Jan van Katwijk,et al.  Application and benefits of formal methods in software development , 1992, Softw. Eng. J..

[4]  W. W. Royce,et al.  Managing the development of large software systems: concepts and techniques , 1987, ICSE '87.

[5]  Jon Louis Bentley.  Bumper-Sticker Computer Science , 1985, Commun. ACM.

[6]  Mikael Hedlund,et al.  The Integration of LOTOS with an Object Oriented Development Method , 1993, FME.

[7]  John Werth,et al.  A Specification Language for Object-Oriented Analysis and Design , 1994, ECOOP.

[8]  Michael Stark.  Impacts of object-oriented technologies: seven years of SEL studies , 1993, OOPSLA '93.

[9]  Ivar Jacobson,et al.  Object-oriented software engineering - a use case driven approach , 1993, TOOLS.

[10]  Ken Shumate,et al.  Structured analysis and object-oriented design are compatible , 1991, ALET.

[11]  Susan Stepney,et al.  Object Orientation in Z , 1992, Workshops in Computing.

[12]  Peter P. Chen.  The entity-relationship model: toward a unified view of data , 1975, VLDB '75.

[13]  S. J. Goldsack,et al.  LOTOS in the Object-Oriented Analysis Process , 1996 .

[14]  Ivar Jacobson,et al.  Object-Oriented Software Engineering , 1991, TOOLS.

[15]  Martin Gogolla,et al.  An Animator for the Object Specification Language TROLL light , 1994, COODBSE.

[16]  Stephen J. Mellor,et al.  Object lifecycles: modeling the world in states , 1992 .

[17]  Gordon S. Blair,et al.  Object-oriented languages, systems and applications , 1991 .

[18]  Gordon Blair u.a..  'OBJECT-ORIENTED LANGUAGES, SYSTEMS AND APPLICATIONS' , 1990 .

[19]  Cliff B. Jones,et al.  Specifications are not (necessarily) executable , 1989 .

[20]  Hassan Gomaa.  The impact of rapid prototyping on specifying user requirements , 1983, SOEN.

[21]  Ana Moreira,et al.  Combining Object-Oriented Analysis and Formal Description Techniques , 1994, ECOOP.

[22]  Valerie M. Jones,et al.  Software design and prototyping using me too , 1989 .

[23]  Norbert E. Fuchs.  Specifications are (preferably) executable , 1992, Softw. Eng. J..

[24]  Anne Elisabeth Haxthausen,et al.  The Raise Specification Language , 1992 .

[25]  Chris Dollin,et al.  Object-oriented development: the fusion method , 1994 .

[26]  Brian Henderson-Sellers,et al.  Object-oriented information system: An introductory tutorial , 1992, Aust. Comput. J..

[27]  David A. Carrington,et al.  Object-Z: An Object-Oriented Extension to Z , 1989, FORTE.

[28]  Darrel C. Ince,et al.  Software prototying—progress and prospects , 1987 .

[29]  Scott Danforth,et al.  Type theories and object-oriented programmimg , 1988, CSUR.

[30]  Franco Civello,et al.  Roles for composite objects in object-oriented analysis and design , 1993, OOPSLA '93.

[31]  C. A. R. Hoare,et al.  How Did Software Get So Reliable Without Proof? , 1996, FME.

[32]  Hartmut Ehrig,et al.  Fundamentals of Algebraic Specification 1 , 1985, EATCS Monographs on Theoretical Computer Science.

[33]  Neal L. Walters.  An ada object-based analysis and design approach , 1991, ALET.

[34]  K. S. Bhaskar.  How object-oriented is your system? , 1983, SIGP.

[35]  David Brookman.  SA/SD vs OOD , 1991, ALET.

[36]  Hans-Jörg Kreowski,et al.  Recent Trends in Data Type Specification , 1985, Informatik-Fachberichte.

[37]  C. Floyd.  A Systematic Look at Prototyping , 1984 .

[38]  Kristen Nygaard,et al.  SIMULA: an ALGOL-based simulation language , 1966, CACM.

[39]  Henk Eertink,et al.  Symbolic execution of LOTOS specifications , 1992, Formal Techniques for (Networked and) Distributed Systems.

[40]  Barry W. Boehm,et al.  Prototyping Versus Specifying: A Multiproject Experiment , 1984, IEEE Transactions on Software Engineering.

[41]  Wei Li.  A Theory of Requirements Capture and Its Applications , 1993, TAPSOFT.

[42]  Harry H. Porter.  Separating the subtype hierarchy from the inheritance of implementation , 1992 .

[43]  Edward Yourdon,et al.  Modern structured analysis , 1989 .

[44]  Leslie Lamport,et al.  The temporal logic of actions , 1994, TOPL.

[45]  Martin Gogolla,et al.  Objects and their Specification , 1991, COMPASS/ADT.

[46]  Steve Rudkin.  Inheritance in LOTOS , 1991, FORTE.

[47]  Rebecca Wirfs-Brock,et al.  Designing object-oriented software , 1990 .

[48]  Jon Louis Bentley,et al.  Programming pearls , 1987, CACM.

[49]  David Lorge Parnas,et al.  A rational design process: How and why to fake it , 1986, IEEE Transactions on Software Engineering.

[50]  Pamela Zave,et al.  An Insider's Evaluation of PAISLey , 1991, IEEE Trans. Software Eng..

[51]  Robert G. Clark.  The design and development of embedded Ada systems , 1990, Softw. Eng. J..

[52]  Michel Diaz,et al.  Formal Description Technique Estelle: Results of the Esprit Sedos Project , 1989 .

[53]  Dennis de Champeaux,et al.  Object-oriented system development , 1993 .

[54]  Richard E. Fairley,et al.  Software engineering concepts , 1985, McGraw-Hill series in software engineering and technology.

[55]  Jay Banerjee,et al.  Composite object support in an object-oriented database system , 1987, OOPSLA 1987.

[56]  Graham Beech,et al.  Software engineering with ada , 1983 .

[57]  Edward V. Berard,et al.  Essays on object-oriented software engineering , 1992 .

[58]  Amiram Yehudai,et al.  OBSERV—a prototyping language and environment , 1992, TSEM.

[59]  H. D. Benington,et al.  Production of Large Computer Programs , 1983, Annals of the History of Computing.

[60]  Barbara Liskov,et al.  Guardians and Actions: Linguistic Support for Robust, Distributed Programs , 1983, TOPL.

[61]  Donald J. Reifer,et al.  Large project experiences with object-oriented methods and reuse , 1993, J. Syst. Softw..

[62]  Barry W. Boehm,et al.  Software Engineering Economics , 1993, IEEE Transactions on Software Engineering.

[63]  James E. Rumbaugh,et al.  Object-Oriented Modelling and Design , 1991 .

[64]  Edward V. Berard,et al.  Essays on object-oriented software engineering (vol. 1) , 1993 .

[65]  G. A. Miller.  THE PSYCHOLOGICAL REVIEW THE MAGICAL NUMBER SEVEN, PLUS OR MINUS TWO: SOME LIMITS ON OUR CAPACITY FOR PROCESSING INFORMATION 1 , 1956 .

[66]  Gunter Saake,et al.  Aggregation in a Behaviour Oriented Object Model , 1992, ECOOP.

[67]  Karl J. Lieberherr,et al.  Object-oriented design , 1996, CSUR.

[68]  Elspeth Cusack,et al.  Object-Oriented Specification on LOTOS and Z, or My Cat Really is Object-Oriented! , 1990, REX Workshop.

[69]  Guttorm Sindre,et al.  On the purpose of object-oriented analysis , 1993, OOPSLA '93.

[70]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[71]  Robert G. Clark,et al.  Use of LOTOS in the formal development of an OSI protocol , 1992, Comput. Commun..

[72]  Robert G. Clark,et al.  Specification Case Studies in ROOA , 1994 .

[73]  Walter L. Hürsch.  Should Superclasses be Abstract? , 1994, ECOOP.

[74]  Luc Duponcheel,et al.  An algebraic data type specification language and its rapid prototyping environment , 1989, ICSE '89.

[75]  Fred P. Brooks,et al.  The Mythical Man-Month , 1975, Reliable Software.

[76]  Pamela Zave,et al.  The operational versus the conventional approach to software development , 1984, CACM.

[77]  Dan Craigen,et al.  An International Survey of Industrial Applications of Formal Methods , 1992, Z User Workshop.

[78]  Roberto Ierusalimschy.  A formal specification for a hierarchy of collections , 1993, Softw. Eng. J..

[79]  D. R. Graham.  Incremental development: review of nonmonolithic life-cycle development models , 1989 .

[80]  Reinhard Gotzhein,et al.  Towards a Basic Reference Model of Open Distributed Processing , 1995, Comput. Networks ISDN Syst..

[81]  Ana Moreira,et al.  Object oriented requirements analysis in an Ada project , 1990, ALET.

[82]  Gill Smith,et al.  Object-oriented analysis , 1988, WADAS '88.

[83]  S. Shlaer,et al.  An object-oriented approach to domain analysis , 1989, SOEN.

[84]  Robert G. Clark.  Using LOTOS in the object-based development of embedded systems , 1992 .

[85]  Pierre America,et al.  Designing an Object-Oriented Programming Language with Behavioural Subtyping , 1990, REX Workshop.

[86]  Robin Milner,et al.  A Calculus of Communicating Systems , 1980, Lecture Notes in Computer Science.

[87]  Cliff B. Jones,et al.  Systematic software development using VDM , 1986, Prentice Hall International Series in Computer Science.

[88]  Thomas Mayr,et al.  Specification of Object-Oriented Systems in LOTOS , 1988, Formal Techniques for (Networked and) Distributed Systems.

[89]  Chris F. Kemerer,et al.  Object-oriented and conventional analysis and design methodologies , 1992, Computer.

[90]  WegnerPeter.  Dimensions of object-based language design , 1987 .

[91]  Chris Smith,et al.  An Object Oriented Interpretation of LOTOS , 1989, FORTE.

[92]  Trevor N. Mudge,et al.  Object-Based Computing and the Ada Programming Language , 1985, Computer.

[93]  Paul T. Ward.  How to integrate object orientation with structured analysis and design , 1989, IEEE Software.

[94]  Chris Gane,et al.  Structured Systems Analysis: Tools and Techniques , 1977 .

[95]  Jay Banerjee,et al.  Composite object support in an object-oriented database system , 1987, OOPSLA '87.

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

[97]  Marvin V. Zelkowitz,et al.  A case study in rapid prototyping , 1980, Softw. Pract. Exp..

[98]  Joseph A. Goguen,et al.  A Categorial Theory of Objects as Observed Processes , 1990, REX Workshop.

[99]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[100]  Anthony Hall,et al.  Seven myths of formal methods , 1990, IEEE Software.

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

[102]  Stephan Merz,et al.  A framework for programming and formalizing concurrent objects , 1993, SIGSOFT '93.

[103]  Cliff B. Jones.  A pi-Calculus Semantics for an Object-Based Design Notation , 1993, CONCUR.

[104]  John Nicholls,et al.  Z notation , 1994 .

[105]  E. Colbert,et al.  The object-oriented software development method: a practical approach to object-oriented development , 1989, TRI-Ada '89.

[106]  Robert Balzer,et al.  On the inevitable intertwining of specification and implementation , 1982, CACM.

[107]  Ashley McClenaghan.  Distributed systems : architecture-driven specification using extended LOTOS , 1993 .

[108]  Neil M. Goldman,et al.  Operational specification as the basis for rapid prototyping , 1982 .

[109]  Peter Wegner.  Dimensions of object-based language design , 1987, OOPSLA 1987.

[110]  Thomas E. Cheatham,et al.  Software Technology in the 1990's: Using a New Paradigm , 1983, Computer.

[111]  O. J. Dahl,et al.  Simula Begin , 1979 .

[112]  Eric Dubois,et al.  O-O Requirements Analysis: an Agent Perspective , 1993, ECOOP.

[113]  Cliff B. Jones,et al.  Software development - a rigorous approach , 1980, Prentice Hall international series in computer science.

[114]  Lawrence Peters,et al.  Advanced structured analysis and design , 1987 .

[115]  Pamela Zave,et al.  Executable requirements for embedded systems , 1981, ICSE '81.

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

[117]  Tommaso Bolognesi,et al.  Tableau methods to describe strong bisimilarity on LOTOS processes involving pure interleaving and enabling , 1994, FORTE.

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

[119]  Diane C. P. Smith,et al.  Database abstractions: aggregation , 1977, CACM.

[120]  Michael F. Smith.  Software Prototyping: Adoption, Practice and Management , 1991 .

[121]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[122]  Hassan Gomaa,et al.  Prototyping as a tool in the specification of user requirements , 1981, ICSE '81.

[123]  C. Choppy.  Prototyping and formal specifications , 1992 .

[124]  Victor R. Basili,et al.  Iterative enhancement: A practical technique for software development , 1975, IEEE Transactions on Software Engineering.

[125]  Bryan Ratcliff.  Early and not-so-early prototyping-rationale and tool support , 1988, Proceedings COMPSAC 88: The Twelfth Annual International Computer Software & Applications Conference.

[126]  P. Kidwell,et al.  The mythical man-month: Essays on software engineering , 1996, IEEE Annals of the History of Computing.

[127]  Grady Booch,et al.  Object-Oriented Design with Applications , 1990 .

[128]  Friederike Nickl,et al.  A Formal Approach to Requirements Engineering (Invited Paper) , 1993, Formal Methods in Programming and Their Applications.

[129]  Jon Bentley,et al.  Programmimg pearls , 1985, CACM.

[130]  S. Rudkin.  Templates, types and classes in open distributed processing : Object oriented technology , 1993 .

[131]  Cristina Sernadas,et al.  Objects, Object Types, and Object Identification , 1988, Categorial Methods in Computer Science.

[132]  Donald Firesmith,et al.  Structured analysis and object-oriented development are not compatible , 1991, ALET.