Reliable Software Technologies - Ada-Europe 2004

Formal methods for software development have been discussed for decades. This paper will try to explain when and under what circumstances formal methods and languages in general and the Object Constraint Language (OCL) in particular can be employed in a beneficial way. The success of using a formal approach is highly influenced by the expectations and pre-requisite knowledge of the developers, the role the formal support in the development process is given, and of course by the used tools.

[1]  John G. P. Barnes,et al.  High Integrity Software - The SPARK Approach to Safety and Security , 2003 .

[2]  Neil C. Audsley,et al.  Hardware implementation of the Ravenscar Ada tasking profile , 2002, CASES '02.

[3]  Friedhelm Meyer auf der Heide,et al.  Dynamic perfect hashing: upper and lower bounds , 1988, [Proceedings 1988] 29th Annual Symposium on Foundations of Computer Science.

[4]  Lui Sha,et al.  Priority Inheritance Protocols: An Approach to Real-Time Synchronization , 1990, IEEE Trans. Computers.

[5]  Paul D. Seymour,et al.  Graph minors. I. Excluding a forest , 1983, J. Comb. Theory, Ser. B.

[6]  Michael González Harbour,et al.  Application-defined scheduling in Ada , 2002 .

[7]  Rocquencourt,et al.  Analysis of Deadline Scheduled Real-Time Systems , 1996 .

[8]  Jens Gustedt,et al.  The Treewidth of Java Programs , 2002, ALENEX.

[9]  Martin Gogolla,et al.  Expressing UML Class Diagrams Properties with OCL , 2002, Object Modeling with the OCL.

[10]  Alan Burns,et al.  Guide for the use of the Ada Ravenscar Profile in high integrity systems , 2004, ALET.

[11]  Alan Burns,et al.  The Ravenscar tasking profile for high integrity real-time programs , 1998, SIGAda '98.

[12]  Christopher R. Houck,et al.  A Genetic Algorithm for Function Optimization: A Matlab Implementation , 2001 .

[13]  José F. Ruiz,et al.  Implementing Ada.Real_Time.Clock and Absolute Delays in Real-Time Kernels , 2001, Ada-Europe.

[14]  Corporate Ieee,et al.  Information Technology-Portable Operating System Interface , 1990 .

[15]  Hans L. Bodlaender,et al.  A Tourist Guide through Treewidth , 1993, Acta Cybern..

[16]  Jean-Bernard Stefani,et al.  Jonathan: an open distributed processing environment in Java , 1999, Distributed Syst. Eng..

[17]  Carlos Delgado Kloos,et al.  A formal method for specification and refinement of real-time systems , 1996, Proceedings of the Eighth Euromicro Workshop on Real-Time Systems.

[18]  Peter T. Breuer,et al.  A prettier compiler‐compiler: Generating higher‐order parsers in C , 1995, Softw. Pract. Exp..

[19]  Mario Aldea Rivas,et al.  Michael González Harbour: MaRTE OS: An Ada Kernel for Real-Time Embedded Applications , 2001, Ada-Europe.

[20]  Gregor Kiczales,et al.  An Architecture for An Open Compiler , 1998 .

[21]  Laurent Pautet,et al.  GLADE: a framework for building large object-oriented real-time distributed systems , 2000, Proceedings Third IEEE International Symposium on Object-Oriented Real-Time Distributed Computing (ISORC 2000) (Cat. No. PR00607).

[22]  J. Javier Gutiérrez,et al.  MAST: Modeling and Analysis Suite for Real Time Applications , 2001, ECRTS.

[23]  Michael González Harbour,et al.  Response time analysis for tasks scheduled under EDF within fixed priorities , 2003, RTSS 2003. 24th IEEE Real-Time Systems Symposium, 2003.

[24]  Tsong Yueh Chen,et al.  Test case selection with and without replacement , 2000, Inf. Sci..

[25]  Juha Kuusela,et al.  Object-oriented technology for real-time systems , 1996 .

[26]  C. Zook,et al.  Growth outside the core. , 2003, Harvard business review.

[27]  Neil C. Audsley,et al.  Hardware implementation of programming languages for real-time , 2002, Proceedings. Eighth IEEE Real-Time and Embedded Technology and Applications Symposium.

[28]  Peter Amey.  A language for systems not just software , 2001, SIGAda '01.

[29]  N. Wilde,et al.  Identifying objects in a conventional procedural language: an example of data design recovery , 1990, Proceedings. Conference on Software Maintenance 1990.

[30]  José F. Ruiz,et al.  An Open Ravenscar Real-Time Kernel for GNAT , 2000, Ada-Europe.

[31]  Daniel G. Bobrow,et al.  Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991) , 1991, SGAR.

[32]  Nicolas Halbwachs,et al.  Synchronous Programming of Reactive Systems , 1992, CAV.

[33]  Ismael Ripoll,et al.  Running Ada on Real-Time Linux , 2003, Ada-Europe.

[34]  Grady Booch,et al.  The design of the C++ Booch Components , 1990, OOPSLA/ECOOP '90.

[35]  A. Fleischmann.  Distributed Systems , 1994, Springer Berlin Heidelberg.

[36]  Dennis Gannon,et al.  Java RMI performance and object model interoperability: experiments with Java/HPC++ , 1998, Concurr. Pract. Exp..

[37]  Pierre Chapront.  Ada+B The Formula for Safety Critical Software Development , 1998, Ada-Europe.

[38]  Peter Amey,et al.  Correctness By Construction: Better Can Also Be Cheaper , 2002 .

[39]  Tullio Vardanega,et al.  Report of session: current real-time AIs , 2003 .

[40]  Jee Mcaaer.  Meta-level Programming with Coda , 1995 .

[41]  Jonathan P. Bowen,et al.  Ten Commandments of Formal Methods , 1995, Computer.

[42]  M. G. Harbour,et al.  Extending Ada's real-time systems annex with the POSIX scheduling services , 2001, IRTAW '00.

[43]  Jim Waldo,et al.  A Note on Distributed Computing , 1996, Mobile Object Systems.

[44]  Steve King,et al.  Is Proof More Cost-Effective Than Testing? , 2000, IEEE Trans. Software Eng..

[45]  David A. Wagner,et al.  MOPS: an infrastructure for examining security properties of software , 2002, CCS '02.

[46]  Laurent Pautet,et al.  Refining Middleware Functions for Verification Purpose , 2003 .

[47]  Rob Williams,et al.  Linux device drivers , 2006 .

[48]  J. Javier Gutiérrez,et al.  RT-EP : Real-Time Ethernet Protocol for Analyzable Distributed Applications on a Minimum Real-Time POSIX Kernel , 2003 .

[49]  Barbara Liskov,et al.  The Argus Language and System , 1984, Advanced Course: Distributed Systems.

[50]  John G. P. Barnes,et al.  Programming in Ada 95 , 1995 .

[51]  Edmund M. Clarke,et al.  Formal Methods: State of the Art and Future Directions Working Group Members , 1996 .

[52]  Andy J. Wellings,et al.  The Ceiling Protocol in Multi-moded Real-Time Systems , 1999, Ada-Europe.

[53]  Douglas C. Schmidt,et al.  Middleware for Distributed Systems Evolving the Common Structure for Network-centric Applications , 2001 .

[54]  Alan Burns,et al.  Adding Temporal Annotations and Associated Verification to Ravenscar Profile , 2003, Ada-Europe.

[55]  Peter T. Breuer.  A Formal Model for the Block Device Subsystem of the Linux Kernel , 2003, ICFEM.

[56]  Henry Ledgard,et al.  Reference Manual for the ADA® Programming Language , 1983, Springer New York.

[57]  Brian Cantwell Smith,et al.  Reflection and semantics in LISP , 1984, POPL.

[58]  Andrew Birrell,et al.  Implementing remote procedure calls , 1984, TOCS.

[59]  Ps Loo,et al.  Random testing revisited , 1988 .

[60]  Ward Rosenberry,et al.  Understanding DCE , 1992 .

[61]  Marie-Claude Gaudel,et al.  Testing from Formal Specifications, a Generic Approach , 2001, Ada-Europe.

[62]  Michael González Harbour,et al.  POSIX-compatible application-defined scheduling in MaRTE OS , 2002, Proceedings 14th Euromicro Conference on Real-Time Systems. Euromicro RTS 2002.

[63]  Roderick Chapman,et al.  Industrial strength exception freedom , 2002, SIGAda.

[64]  Shigeru Chiba,et al.  OpenJava: A Class-Based Macro System for Java , 1999, Reflection and Software Engineering.

[65]  Xavier Franch,et al.  A framework for designing and implementing the Ada standard container library , 2003, SIGAda.

[66]  Laurent Pautet,et al.  Inside the Distributed Systems Annex , 1998, Ada-Europe.

[67]  Jean-Marc Geib,et al.  CorbaWeb: A Generic Object Navigator , 1996, Comput. Networks.

[68]  Edsger W. Dijkstra,et al.  The end of computing science? , 2001, CACM.

[69]  Erhard Plödereder,et al.  Where Does GOTO Go to? , 1996, Ada-Europe.

[70]  Andrew P. Black,et al.  The Eden System: A Technical Review , 1985, IEEE Transactions on Software Engineering.

[71]  Jon G. Hall,et al.  Mandated Requirements for Hardware / Software Combination in Safety-Critical Systems , 2002 .

[72]  Shyam Chetty,et al.  Design, Development and Flight Testing of Control Laws for the Indian Light Combat Aircraft , 2002 .

[73]  Matthew Heaney.  Charles: A Data Structure Library for Ada95 , 2003, Ada-Europe.

[74]  Chap-Liong Ong.  Class and object extraction from imperative code , 1994 .

[75]  Adrian J. Hilton,et al.  High integrity hardware-software codesign , 2004 .

[76]  Emmanuel Briot,et al.  GtkAda: Design and Implementation of a High Level Binding in Ada , 2000, Ada-Europe.

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

[78]  Michael Barabanov,et al.  A Linux-based Real-Time Operating System , 1997 .

[79]  Shigeru Chiba.  A study of a Compile-time Metaobject Protocol , 1996 .

[80]  Michael S. Hsiao,et al.  Embedded core testing using genetic algorithms , 2000, Proceedings of the Ninth Asian Test Symposium.

[81]  Theodore Johnson,et al.  A new approach to finding objects in programs , 1994, J. Softw. Maintenance Res. Pract..

[82]  J. Javier Gutiérrez,et al.  Prioritizing remote procedure calls in Ada distributed systems , 1999, IRTAW.

[83]  Jonathan P. Bowen,et al.  Seven More Myths of Formal Methods , 1994, FME.

[84]  Richard Gerber,et al.  Compiling Real-Time Programs With Timing Constraint Refinement and Structural Code Motion , 1995, IEEE Trans. Software Eng..

[85]  Alan Burns,et al.  Report of session: generating new AIs , 2003 .

[86]  Timothy J. Budden.  Decision Point:Will Using a COTS Component Help or Hinder Your DO-178B Certification Effort? © , 2003 .

[87]  Xavier Franch,et al.  Reengineering the Booch Component Library , 2000, Ada-Europe.

[88]  James W. Layland,et al.  Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment , 1989, JACM.

[89]  Mikkel Thorup,et al.  All Structured Programs have Small Tree-Width and Good Register Allocation , 1998, Inf. Comput..

[90]  Larry Carter,et al.  Distrbution and Abstract Types in Emerald , 1987, IEEE Transactions on Software Engineering.

[91]  N. C. Audsley,et al.  Language issues of compiling Ada to hardware , 2002, IRTAW '02.

[92]  Patrick Cousot,et al.  Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints , 1977, POPL.

[93]  Dave Towey,et al.  Normalized Restricted Random Testing , 2003, Ada-Europe.

[94]  Andy J. Wellings,et al.  Dual priority scheduling , 1995, Proceedings 16th IEEE Real-Time Systems Symposium.

[95]  Pattie Maes,et al.  Concepts and experiments in computational reflection , 1987, OOPSLA '87.

[96]  Christoph M. Kirsch,et al.  Principles of Real-Time Programming , 2002, EMSOFT.

[97]  Tullio Vardanega.  Development of on-board embedded real-time systems: an engineering approach , 1998 .

[98]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[99]  Tsong Yueh Chen,et al.  Proportional sampling strategy: a compendium and some insights , 2001, J. Syst. Softw..

[100]  Juan Zamorano,et al.  Execution-time clocks and Ravenscar kernels , 2003 .

[101]  B. M. Yelavich.  Customer Information Control System - An Evolving System Facility , 1985, IBM Syst. J..

[102]  Alok Srivastava.  Ada Issue 00355: priority specific dispatching including round robin , 2006, ALET.

[103]  William E. Lorensen,et al.  Object-Oriented Modeling and Design , 1991, TOOLS.

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

[105]  P. S. Subramanyam,et al.  Testing Safety Critical Ada Code Using Non Real Time Testing , 2003, Ada-Europe.

[106]  Kwei-Jay Lin,et al.  Dynamic priority ceilings: A concurrency control protocol for real-time systems , 1990, Real-Time Systems.

[107]  Harry Katzan.  Invitation to ADA , 1990 .

[108]  Alfons Crespo,et al.  Dynamic ceiling priorities in GNAT implementation report , 2003 .

[109]  Laurent Pautet,et al.  GARLIC: generic Ada reusable library for interpartition communication , 1995, TRI-Ada '95.

[110]  Michael González Harbour,et al.  Towards a real-time distributed systems annex in Ada , 2001, IRTAW '00.

[111]  Theodore P. Baker,et al.  Stack-based scheduling of realtime processes , 1991, Real-Time Systems.

[112]  Peter Amey.  Closing the Loop: The Influence of Code Analysis on Design , 2002, Ada-Europe.

[113]  Alan Burns,et al.  Protected ceiling changes , 2002, IRTAW '02.

[114]  M. F. Bowen.  Handel-c language reference manual , 1998 .

[115]  Tsong Yueh Chen,et al.  Proportional sampling strategy: guidelines for software testing practitioners , 1996, Inf. Softw. Technol..

[116]  Adrian J. Hilton,et al.  Refining specifications to programmable logic , 2002, Electron. Notes Theor. Comput. Sci..

[117]  Distributed Computation,et al.  Object-oriented parallel and distributed programming , 2000 .

[118]  L. Sha,et al.  The priority ceiling protocol: A method for minimizing the blocking of high priority Ada tasks , 1988, IRTAW '88.

[119]  Dave Towey,et al.  Restricted Random Testing , 2002, ECSQ.

[120]  José M. Drake,et al.  Modeling and schedulability analysis in the development of real-time distributed Ada systems , 2002, IRTAW '02.

[121]  Alan Burns,et al.  Preemptive priority-based scheduling: an appropriate engineering approach , 1995 .

[122]  Alan Burns,et al.  Dual Priority Scheduling in ADA 95 and Real-Time Posix , 1996 .

[123]  Sun Microsystems,et al.  RPC: Remote Procedure Call Protocol specification , 1988, RFC.

[124]  Alan Burns,et al.  A Round Robin Scheduling Policy for Ada , 2003, Ada-Europe.

[125]  Laurent Pautet,et al.  CORBA & DSA: Divorce or Marriage? , 1999, Ada-Europe.

[126]  Colin J. Fidge,et al.  The deadline command , 1999, IEE Proc. Softw..

[127]  Mayuram S. Krishnan,et al.  Evaluating the cost of software quality , 1998, CACM.

[128]  Shigeru Chiba,et al.  A metaobject protocol for C++ , 1995, OOPSLA.

[129]  Ian C. Parmee,et al.  35 Years On: to What Extent Has Software Engineering Design Achieved Its Goals? , 2003, IEE Proc. Softw..

[130]  Brian Dobbing,et al.  Session: status and future of the Ravenscar profile , 2003 .

[131]  Derek G. Corneil,et al.  Complexity of finding embeddings in a k -tree , 1987 .

[132]  S. Moody.  Object-oriented real-time systems using a hybrid distributed model of Ada 95's built-in DSA capability (distributed systems annex-E) and CORBA , 1997, IRTAW '97.

[133]  Sampath Kannan,et al.  Register allocation in structured programs , 1995, SODA '95.

[134]  Neil C. Audsley,et al.  Hardware compilation of sequential ada , 2001, CASES '01.

[135]  David R. Musser,et al.  STL tutorial and reference guide , 2001 .

[136]  Bernard Carré,et al.  Information-flow and data-flow analysis of while-programs , 1985, TOPL.

[137]  Peter P. Puschner,et al.  Calculating the maximum execution time of real-time programs , 1989, Real-Time Systems.

[138]  Thomas A. Henzinger,et al.  Giotto: a time-triggered language for embedded programming , 2001, Proc. IEEE.