The role of formalism in system requirements (full version)

A major determinant of the quality of software systems is the quality of their requirements, which should be both understandable and precise. Most requirements are written in natural language, good for understandability but lacking in precision. To make requirements precise, researchers have for years advocated the use of mathematics-based notations and methods, known as "formal". Many exist, differing in their style, scope and applicability. The present survey discusses some of the main formal approaches and compares them to informal methods. The analysis uses a set of 9 complementary criteria, such as level of abstraction, tool availability, traceability support. It classifies the approaches into five categories: general-purpose, natural-language, graph/automata, other mathematical notations, seamless (programming-language-based). It presents approaches in all of these categories, altogether 22 different ones, including for example SysML, Relax, Eiffel, Event-B, Alloy. The review discusses a number of open questions, including seamlessness, the role of tools and education, and how to make industrial applications benefit more from the contributions of formal approaches. (This is the full version of the survey, including some sections and two appendices which, because of length restrictions, do not appear in the submitted version.)

[1]  Michael A. Jackson,et al.  Problem Frames - Analysing and Structuring Software Development Problems , 2000 .

[2]  Steve A. Schneider,et al.  The behavioural semantics of Event-B refinement , 2012, Formal Aspects of Computing.

[3]  Pascal Raymond,et al.  Specifying and Executing Reactive Scenarios With Lutin , 2008, SLA++P@ETAPS.

[4]  Fabiano Dalpiaz,et al.  Teaching Goal Modeling in Undergraduate Education , 2015, iStarT@CAiSE.

[5]  Brian Berenbach,et al.  The use of a requirements modeling language for industrial applications , 2012, 2012 20th IEEE International Requirements Engineering Conference (RE).

[6]  Dennis M. Buede,et al.  6.3.1 Properties of a High Quality Informal Requirements Document , 2000 .

[7]  Manuel Mazzara,et al.  Towards a formalism-based toolkit for automotive applications , 2013, 2013 1st FME Workshop on Formal Methods in Software Engineering (FormaliSE).

[8]  Alexandr Naumchev Object-oriented requirements: reusable, understandable, verifiable , 2019, TOOLS.

[9]  Florian Galinier,et al.  AutoReq: Expressing and verifying requirements for control systems , 2019, J. Comput. Lang..

[10]  Jameleddine Hassine AsmL-Based Concurrency Semantic Variations for Timed Use Case Maps , 2010, ASM.

[11]  Brian Berenbach,et al.  Towards a unified Requirements Modeling Language , 2010, 2010 Fifth International Workshop on Requirements Engineering Visualization.

[12]  Laurie Williams,et al.  Automated extraction of non-functional requirements in available documentation , 2013, 2013 1st International Workshop on Natural Language Analysis in Software Engineering (NaturaLiSE).

[13]  François E. Cellier,et al.  Continuous system modeling , 1991 .

[14]  Manuel Mazzara,et al.  A pi-calculus based semantics for WS-BPEL , 2007, J. Log. Algebraic Methods Program..

[15]  Marvin Minsky,et al.  Computation : finite and infinite machines , 2016 .

[16]  Jordi Cabot,et al.  UMLtoCSP: a tool for the formal verification of UML/OCL models using constraint programming , 2007, ASE.

[17]  Bertrand Meyer,et al.  Unifying Requirements and Code: An Example , 2015, Ershov Memorial Conference.

[18]  Axel van Lamsweerde,et al.  Goal-oriented requirements enginering: a roundtrip from research to practice [enginering read engineering] , 2004, Proceedings. 12th IEEE International Requirements Engineering Conference, 2004..

[19]  Robert B. France,et al.  Model-driven development using UML 2.0: promises and pitfalls , 2006, Computer.

[20]  Seok-Won Lee,et al.  Evaluating the use of model-based requirements verification method: A feasibility study , 2011, Workshop on Empirical Requirements Engineering (EmpiRE 2011).

[21]  Peter Becker,et al.  A Survey of Formal Concept Analysis Support for Software Engineering Activities , 2005, Formal Concept Analysis.

[22]  David Lorge Parnas,et al.  Predicate Logic for Software Engineering , 1993, IEEE Trans. Software Eng..

[23]  Jameleddine Hassine,et al.  An empirical approach toward the resolution of conflicts in goal-oriented models , 2017, Software & Systems Modeling.

[24]  Ali Idri,et al.  Requirements engineering education: a systematic mapping study , 2013, Requirements Engineering.

[25]  Shaoying Liu,et al.  Teaching formal methods in the context of software engineering , 2009, SGCS.

[26]  Frédéric Boniol,et al.  The Landing Gear System Case Study , 2014, ABZ.

[27]  Gavin Lowe,et al.  Breaking and Fixing the Needham-Schroeder Public-Key Protocol Using FDR , 1996, Softw. Concepts Tools.

[28]  Nikolai Tillmann,et al.  Discovering Likely Method Specifications , 2006, ICFEM.

[29]  Robyn R. Lutz,et al.  Analyzing software requirements errors in safety-critical, embedded systems , 1993, [1993] Proceedings of the IEEE International Symposium on Requirements Engineering.

[30]  Eric S. K. Yu,et al.  Towards modelling and reasoning support for early-phase requirements engineering , 1997, Proceedings of ISRE '97: 3rd IEEE International Symposium on Requirements Engineering.

[31]  Vibha Sazawal,et al.  Chief Chefs of Z to Alloy: Using a Kitchen Example to Teach Alloy with Z , 2009, TFM.

[32]  Dominique Méry,et al.  Teaching Formal Methods: Lessons to Learn , 1998, IWFM.

[33]  Daniel Amyot,et al.  Introduction to the User Requirements Notation: learning by example , 2003, Comput. Networks.

[34]  Peter Gorm Larsen,et al.  Practice-oriented courses in formal methods using VDM++ , 2008, Formal Aspects of Computing.

[35]  Bertrand Meyer,et al.  Complete Contracts through Specification Drivers , 2016, 2016 10th International Symposium on Theoretical Aspects of Software Engineering (TASE).

[36]  J. van Katwijk,et al.  VDM++, a formal specification language for object-oriented designs , 1992, CompEuro 1992 Proceedings Computer Systems and Software Engineering.

[37]  Camilo Rueda,et al.  Teaching Formal Methods for the Unconquered Territory , 2009, TFM.

[38]  Manuel Mazzara,et al.  Towards Abstractions for Web Services Composition , 2006 .

[39]  Jane Sinclair,et al.  Motivating Study of Formal Methods in the Classroom , 2004, TFM.

[40]  Didar Zowghi,et al.  Teaching requirements engineering through role playing: lessons learnt , 2003, Proceedings. 11th IEEE International Requirements Engineering Conference, 2003..

[41]  Bertrand Meyer A Framework for Proving Contract-Equipped Classes , 2003, Abstract State Machines.

[42]  Jean-Raymond Abrial,et al.  The B-book - assigning programs to meanings , 1996 .

[43]  Kim G. Larsen,et al.  Teaching Concurrency: Theory in Practice , 2009, TFM.

[44]  Michael Jackson,et al.  Four dark corners of requirements engineering , 1997, TSEM.

[45]  David Lorge Parnas,et al.  Tabular Representation of Relations , 1992 .

[46]  Robert Morris,et al.  Chord: A scalable peer-to-peer lookup service for internet applications , 2001, SIGCOMM 2001.

[47]  Takako Nakatani Requirements Engineering Education for Professional Engineers , 2008, JCKBSE.

[48]  David Lorge Parnas,et al.  Precise Documentation: The Key to Better Software , 2010, The Future of Software Engineering.

[49]  Michael T. Grinder Animating automata: a cross-platform program for teaching finite automata , 2002, SIGCSE '02.

[50]  Nelly Bencomo,et al.  RELAX: Incorporating Uncertainty into the Specification of Self-Adaptive Systems , 2009, 2009 17th IEEE International Requirements Engineering Conference.

[51]  Daniel Amyot,et al.  User Requirements Notation: The First Ten Years, The Next Ten Years (Invited Paper) , 2011, J. Softw..

[52]  Axel van Lamsweerde,et al.  Goal-Oriented Requirements Engineering: A Guided Tour , 2001, RE.

[53]  Sean Bechhofer,et al.  OWL: Web Ontology Language , 2009, Encyclopedia of Database Systems.

[54]  David Harel,et al.  Statecharts: A Visual Formalism for Complex Systems , 1987, Sci. Comput. Program..

[55]  Aarne Ranta,et al.  An Authoring Tool for Informal and Formal Requirements Specifications , 2002, FASE.

[56]  Alexandr Naumchev,et al.  Seamless Object-Oriented Requirements , 2019, 2019 International Multi-Conference on Engineering, Computer and Information Sciences (SIBIRCON).

[57]  Alexander Verbraeck,et al.  User requirements modeling and analysis of software-intensive systems , 2011, J. Syst. Softw..

[58]  Phillip A. Laplante,et al.  Requirements Engineering for Software and Systems , 2009 .

[59]  Bertrand Meyer,et al.  Programs That Test Themselves , 2009, Computer.

[60]  Martyn Thomas,et al.  Industrial Deployment of System Engineering Methods , 2013, Springer Berlin Heidelberg.

[61]  Jean-Raymond Abrial,et al.  Modeling in event-b - system and software engineering by Jean-Raymond Abrial , 2010, SOEN.

[62]  C. Neville Dean,et al.  Teaching and learning formal methods , 1996 .

[63]  Jeff Magee,et al.  Concurrency - state models and Java programs , 2006 .

[64]  Richard F. Paige,et al.  The Single Model Principle , 2002, J. Object Technol..

[65]  Doheon Lee,et al.  Fuzzy branching temporal logic , 2004, IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics).

[66]  John Mylopoulos,et al.  Why Goal-Oriented Requirements Engineering , 1998, Requirements Engineering: Foundation for Software Quality.

[67]  Wong Cheng In,et al.  Informal, semi-formal, and formal approaches to the specification of software requirements , 1994 .

[68]  Daniel Jackson,et al.  Software Abstractions - Logic, Language, and Analysis , 2006 .

[69]  Heiko Behrens,et al.  Xtext: implement your language faster than the quick and dirty way , 2010, SPLASH/OOPSLA Companion.

[70]  Emilia Villani,et al.  PETRI NET AND OO FOR THE MODULAR ANALYSIS OF AN AIRCRAFT LANDING SYSTEM , 2003 .

[71]  Constance L. Heitmeyer,et al.  Automated consistency checking of requirements specifications , 1996, TSEM.

[72]  David Lorge Parnas,et al.  Using Test Oracles Generated from Program Documentation , 1998, IEEE Trans. Software Eng..

[73]  Luisa Mich,et al.  NL-OOPS: from natural language to object oriented requirements using the natural language processing system LOLITA , 1996, Natural Language Engineering.

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

[75]  Florian Galinier,et al.  A contract-based method to specify stimulus-response requirements , 2017, ArXiv.

[76]  Mark Stansfield,et al.  Evaluation of a game to teach requirements collection and analysis in software engineering at tertiary education level , 2011, Comput. Educ..

[77]  Chokri Mraidha,et al.  Enhancing UML extensions with operational semantics behaviored profiles with templates , 2007, MODELS'07.

[78]  Andrew William Roscoe,et al.  The Theory and Practice of Concurrency , 1997 .

[79]  Jeannette M. Wing A study of 12 specifications of the library problem , 1988, IEEE Software.

[80]  Alain Finkel,et al.  Using mental imagery processes for teaching and research in mathematics and computer science , 2010 .

[81]  Stephen Fickas,et al.  Goal-Directed Requirements Acquisition , 1993, Sci. Comput. Program..

[82]  Nikolai Tillmann,et al.  Pex-White Box Test Generation for .NET , 2008, TAP.

[83]  Axel van Lamsweerde,et al.  Formal specification: a roadmap , 2000, ICSE '00.

[84]  Amel Mammar,et al.  Modeling a landing gear system in Event-B , 2015, International Journal on Software Tools for Technology Transfer.

[85]  E. F. Codd,et al.  A relational model of data for large shared data banks , 1970, CACM.

[86]  Marc Pouzet,et al.  A conservative extension of synchronous data-flow with state machines , 2005, EMSOFT.

[87]  George S. Avrunin,et al.  Property specification patterns for finite-state verification , 1998, FMSP '98.

[88]  Jameleddine Hassine,et al.  A questionnaire-based survey methodology for systematically validating goal-oriented models , 2015, Requirements Engineering.

[89]  Nikolai Tillmann,et al.  Parameterized unit tests , 2005, ESEC/FSE-13.

[90]  Pamela Zave,et al.  Reasoning About Identifier Spaces: How to Make Chord Correct , 2016, IEEE Transactions on Software Engineering.

[91]  Fuyuki Ishikawa,et al.  What Top-Level Software Engineers Tackle after Learning Formal Methods: Experiences from the Top SE Project , 2009, TFM.

[92]  Alexandr Naumchev Seamless Object-Oriented Requirements. (Exigences orientées objets dans un cycle de vie continu) , 2019 .