Automated rapid prototyping of TUG specifications using Prolog

Abstract A prototype is usually built quickly and cheaply to explore poorly understood user requirements in the front-end of the software development life cycle. There are several techniques to construct a prototype such as fourth generation languages, functional and logic programming languages, and simulation techniques. Despite their benefits, these techniques do not directly support formal user requirements and specifications. In this paper, a formal specification language, called TUG, is presented to support an automatic derivation of a prototype in Prolog from a specification in the language via a set of transformation rules. The work described in this paper is distinct from existing rapid prototyping techniques. There is a close correspondence between TUG and Prolog that makes the process of transformation relatively mechanical. The process also allows specifiers not to consider low-level details at implementation such as selection of data structures and algorithms due to the features of the TUG specification language and the Prolog programming language. In addition, rederivation of a prototype in Prolog from a TUG specification is also avoided whenever the specification is modified. A Change Request Script is used to update the prototype in response to the revised specification. The prototype construction and specification acquisition are integrated to handle the construction of user requirements. The formality of the TUG specification language improves the quality of the description of user requirements. Rapid prototyping from the specification via software transformations improves the understanding of user requirements in a cost effective way.

[1]  José Meseguer,et al.  Rapid prototyping: in the OBJ executable specification language , 1982, Rapid Prototyping.

[2]  David H. D. Warren,et al.  Definite Clause Grammars for Language Analysis - A Survey of the Formalism and a Comparison with Augmented Transition Networks , 1980, Artif. Intell..

[3]  Kees M. van Hee,et al.  Z and High Level Petri Nets , 1991, VDM Europe.

[4]  Barry Eaglestone,et al.  Software development: two approaches to animation of Z specifications using Prolog , 1992, Softw. Eng. J..

[5]  Chia-Chu Chiang,et al.  Validating software specifications against user claims , 1999, Proceedings. Twenty-Third Annual International Computer Software and Applications Conference (Cat. No.99CB37032).

[6]  Andy Evans Visualising Concurrent Z Specifications , 1994, Z User Workshop.

[7]  Pamela Zave,et al.  An Operational Approach to Requirements Specification for Embedded Systems , 1982, IEEE Transactions on Software Engineering.

[8]  Peter Baumann,et al.  A Framework for the Specification of Reactive and Concurrent Systems in Z , 1995, FSTTCS.

[9]  Peter Henderson,et al.  An experiment in structured programming , 1972 .

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

[11]  Raymond J. A. Buhr,et al.  Temporal Logic-Based Deadlock Analysis For Ada , 1991, IEEE Trans. Software Eng..

[12]  Johan Lewi,et al.  Algebraic Specifications in Software Engineering , 1989, Springer Berlin Heidelberg.

[13]  Antoni Diller,et al.  Z - an introduction to formal methods , 1990 .

[14]  Derek Andrews,et al.  Specification aspects of VDM , 1988 .

[15]  Dines Bjørner,et al.  VDM - A Formal Method at Work: Proceedings of the VDM-Europe Symposium (VDM '87), Brussels, Belgium, 23-26 March 1987 , 1987 .

[16]  Xudong He,et al.  PZ nets a formal method integrating Petri nets with Z , 2001, Inf. Softw. Technol..

[17]  James J. Horning,et al.  The Larch Family of Specification Languages , 1985, IEEE Software.

[18]  Stephen J. Garland,et al.  Larch: Languages and Tools for Formal Specification , 1993, Texts and Monographs in Computer Science.

[19]  Doris L. Carver,et al.  Experiences in translating Z designs to haskell implementations , 1994, Softw. Pract. Exp..

[20]  Peter Henderson,et al.  Executing formal specifications need not be harmful , 1996, Softw. Eng. J..

[21]  Ian J. Hayes,et al.  Specification case studies , 1987 .

[22]  G. O'Neill Automatic Translation of VDM Specifications into Standard ML Programs (Short Note) , 1992, Comput. J..

[23]  M. I. Jackson,et al.  Developing ada programs using the vienna development method (VDM) , 1985, Softw. Pract. Exp..

[24]  Peter A. Lindsay,et al.  mural: A Formal Development Support System , 1991, Springer London.

[25]  Boutheina Chetali Formal Verification of Concurrent Programs Using the Larch Prover , 1998, IEEE Trans. Software Eng..

[26]  Luqi,et al.  Using Transformations in Specification-Based Prototyping , 1993, IEEE Trans. Software Eng..

[27]  Walter F. Tichy,et al.  Proceedings 25th International Conference on Software Engineering , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[28]  Dines Bjørner,et al.  VDM '87 VDM — A Formal Method at Work , 1987, Lecture Notes in Computer Science.

[29]  Jan A. Bergstra,et al.  Algebraic specification , 1989 .

[30]  Tadao Kasami,et al.  Functional programming and logical programming for the telegram analysis problem , 1984, ICSE '84.

[31]  Doris L. Carver,et al.  Z meets Haskell: A case study , 1993, Proceedings of 1993 IEEE 17th International Computer Software and Applications Conference COMPSAC '93.

[32]  Christine Choppy,et al.  ASSPEGIQUE: An Integrated Environment for Algebraic Specifications , 1985, TAPSOFT, Vol.2.

[33]  Chia-Chu Chiang,et al.  Scalable templates for specification reuse , 1997, Proceedings Twenty-First Annual International Computer Software and Applications Conference (COMPSAC'97).

[34]  Fernando Pereira,et al.  Definite clause grammars for language analysis , 1986 .

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

[36]  Tadao Kasami,et al.  Logical Programming for the Telegram Analysis Problem , 1987, Comput. Lang..

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

[38]  Paolo Nesi,et al.  An Interval Logic for Real-Time System Specification , 2001, IEEE Trans. Software Eng..

[39]  Radimír Vrba,et al.  Executable Specifications for Embedded Distributed Systems , 2001, Computer.

[40]  G. G. Stokes "J." , 1890, The New Yale Book of Quotations.

[41]  Kenneth J. Turner,et al.  Using Formal Description Techniques: An Introduction to Estelle, Lotos, and SDL , 1993 .

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

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

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

[45]  William F. Clocksin,et al.  Programming in Prolog , 1987, Springer Berlin Heidelberg.

[46]  J. Michael Spivey,et al.  The Z notation - a reference manual , 1992, Prentice Hall International Series in Computer Science.

[47]  James J. Horning,et al.  A Larch Shared Language Handbook , 1986, Sci. Comput. Program..

[48]  Paul Krause,et al.  Computer Aided Transformation of Z into Prolog , 1989, Z User Workshop.

[49]  Tommaso Bolognesi,et al.  LOTOSphere: Software Development with LOTOS , 1995, Springer US.

[50]  Pamela Zave,et al.  Salient features of an executable specification language and its environment , 1986, IEEE Transactions on Software Engineering.

[51]  Ben C. Moszkowski,et al.  A complete axiomatization of interval temporal logic with infinite time , 2000, Proceedings Fifteenth Annual IEEE Symposium on Logic in Computer Science (Cat. No.99CB36332).