SAVCBS 2004 Specification and Verification of Component-Based Systems: Workshop Proceedings

This is the proceedings of the 2004 SAVCBS workshop. The workshop is concerned with how formal (i.e., mathematical) techniques can be or should be used to establish a suitable foundation for the specification and verification of component-based systems. Component-based systems are a growing concern for the software engineering community. Specification and reasoning techniques are urgently needed to permit composition of systems from components. Component-based specification and verification is also vital for scaling advanced verification techniques such as extended static analysis and model checking to the size of real systems. The workshop considers formalization of both functional and non-functional behavior, such as performance or reliability.

[1]  Ivan Porres.  Modeling and Analyzing Software Behavior in UML , 1910 .

[2]  Alfred Tarski,et al.  Relational selves as self-affirmational resources , 2008 .

[3]  A. Tarski.  A Decision Method for Elementary Algebra and Geometry , 2023 .

[4]  Hilary Putnam,et al.  A Computing Procedure for Quantification Theory , 1960, JACM.

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

[6]  Boris A. Trakhtenbrot,et al.  Finite automata : behavior and synthesis , 1973 .

[7]  C. A. R. Hoare,et al.  Monitors: an operating system structuring concept , 1974, CACM.

[8]  James C. King,et al.  Symbolic execution and program testing , 1976, CACM.

[9]  Jeffrey D. Ullman,et al.  Introduction to Automata Theory, Languages and Computation , 1979 .

[10]  Cliff B. Jones,et al.  Tentative steps toward a development method for interfering programs , 1983, TOPL.

[11]  Leslie Lamport,et al.  Specifying Concurrent Program Modules , 1983, TOPL.

[12]  K. Mani Chandy,et al.  The drinking philosophers problem , 1984, ACM Trans. Program. Lang. Syst..

[13]  Mark Weiser,et al.  Program Slicing , 1981, IEEE Transactions on Software Engineering.

[14]  Eugene W. Stark,et al.  A Proof Technique for Rely/Guarantee Properties , 1985, FSTTCS.

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

[16]  Matthias Felleisen,et al.  Hygienic macro expansion , 1986, LFP '86.

[17]  Barbara Liskov,et al.  Program Development in Java - Abstraction, Specification, and Object-Oriented Design , 1986 .

[18]  Dana Angluin,et al.  Learning Regular Sets from Queries and Counterexamples , 1987, Inf. Comput..

[19]  Peter Sommerlad,et al.  Pattern-Oriented Software Architecture: A System of Patterns: John Wiley & Sons , 1987 .

[20]  C. A. R. Hoare,et al.  Laws of programming , 1987, CACM.

[21]  Nancy A. Lynch,et al.  Hierarchical correctness proofs for distributed algorithms , 1987, PODC '87.

[22]  Pierre America,et al.  Inheritance and Subtyping in a Parallel Object-Oriented Language , 1987, ECOOP.

[23]  B. Meyer.  Object-Oriented Software Construction , 1988 .

[24]  K. Mani Chandy,et al.  Parallel program design - a foundation , 1988 .

[25]  李幼升,et al.  Ph , 1989 .

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

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

[28]  David W. Binkley,et al.  Interprocedural slicing using dependence graphs , 1990, TOPL.

[29]  Laura K. Dillon,et al.  Using symbolic execution for verification of Ada tasking programs , 1990, TOPL.

[30]  Bjarne Stroustrup,et al.  The Annotated C++ Reference Manual , 1990 .

[31]  Jeannette M. Wing.  A specifier's introduction to formal methods , 1990, Computer.

[32]  Bruce W. Weide,et al.  Copying and Swapping: Influences on the Design of Reusable Software Components , 1991, IEEE Trans. Software Eng..

[33]  Gilad Bracha,et al.  The programming language jigsaw: mixins, modularity and multiple inheritance , 1992 .

[34]  Richard C. Holt,et al.  The Geneva convention on the treatment of object aliasing , 1992, OOPS.

[35]  Gregor Kiczales,et al.  Issues in the Design and Documentation of Class Libraries , 1992, OOPSLA.

[36]  Edmund M. Clarke,et al.  Verification Tools for Finite-State Concurrent Systems , 1993, REX School/Symposium.

[37]  David J. Robson,et al.  The state-based testing of object-oriented programs , 1993, 1993 Conference on Software Maintenance.

[38]  Daniel Weise,et al.  Programmable syntax macros , 1993, PLDI '93.

[39]  Oscar Nierstrasz,et al.  Regular types for active objects , 1993, OOPSLA '93.

[40]  Nils Klarlund,et al.  Graph types , 1993, POPL '93.

[41]  S. Balemi,et al.  Supervisory control of a rapid thermal multiprocessor , 1993, IEEE Trans. Autom. Control..

[42]  Pierre Collette,et al.  Composition of Assumption-Commitment Specifications in a UNITY Style , 1994, Sci. Comput. Program..

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

[44]  William F. Ogden,et al.  Modular Verification of Data Abstractions with Shared Realizations , 1994, IEEE Trans. Software Eng..

[45]  Jeannette M. Wing,et al.  A behavioral notion of subtyping , 1994, TOPL.

[46]  Bruce Weide,et al.  Component-based software using RESOLVE , 1994, SOEN.

[47]  David Chenho Kung,et al.  On object state testing , 1994, Proceedings Eighteenth Annual International Computer Software and Applications Conference (COMPSAC 94).

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

[49]  Orna Grumberg,et al.  Model checking and modular verification , 1994, TOPL.

[50]  Natarajan Shankar,et al.  Formal Verification for Fault-Tolerant Architectures: Prolegomena to the Design of PVS , 1995, IEEE Trans. Software Eng..

[51]  Trygve Reenskaug,et al.  Working with objects , 1995 .

[52]  Jeannette M. Wing,et al.  Specification matching of software components , 1995, TSEM.

[53]  Frank Tip,et al.  A survey of program slicing techniques , 1994, J. Program. Lang..

[54]  Moshe Y. Vardi.  On the complexity of modular model checking , 1995, Proceedings of Tenth Annual IEEE Symposium on Logic in Computer Science.

[55]  Thomas W. Reps,et al.  Precise interprocedural dataflow analysis via graph reachability , 1995, POPL '95.

[56]  Gregor Kiczales,et al.  Aspect-oriented programming , 1996, CSUR.

[57]  Sérgio Vale Aguiar Campos,et al.  Symbolic Model Checking , 1993, CAV.

[58]  Kim Mens,et al.  Vrije Universiteit Brussel Faculteit Wetenschappen Reuse Contracts: Managing the Evolution of Reusable Assets Reuse Contracts: Managing the Evolution of Reusable Assets , 2022 .

[59]  Mary Shaw,et al.  Software architecture - perspectives on an emerging discipline , 1996 .

[60]  Doug Lea,et al.  Concurrent Programming In Java , 1996 .

[61]  Wayne D. Heym.  Computer program verification: improvements for human reasoning , 1996 .

[62]  Dirk Riehle,et al.  Understanding and Using Patterns in Software Development , 1996, Theory Pract. Object Syst..

[63]  Jayadev Misra.  A discipline of multiprogramming , 1996, CSUR.

[64]  Nils Klarlund,et al.  Automatic verification of pointer programs using monadic second-order logic , 1997, PLDI '97.

[65]  Jeffrey M. Voas.  Quality Time: How Assertions Can Increase Test Effectiveness , 1997, IEEE Softw..

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

[67]  Johann Schumann,et al.  NORA/HAMMR: making deduction-based software component retrieval practical , 1997, Proceedings 12th IEEE International Conference Automated Software Engineering.

[68]  Michael Burrows,et al.  Eraser: a dynamic data race detector for multi-threaded programs , 1997, TOCS.

[69]  Ludwig Staiger,et al.  On Syntactic Congruences for Omega-Languages , 1997, Theor. Comput. Sci..

[70]  Dirk Riehle.  Composite design patterns , 1997, OOPSLA '97.

[71]  Clemens Szyperski,et al.  Component software , 1997 .

[72]  Gerard J. Holzmann,et al.  The Model Checker SPIN , 1997, IEEE Trans. Software Eng..

[73]  Murali Sitaraman,et al.  On the Practical Need for Abstraction Relations to Verify Abstract Data Type Representations , 1997, IEEE Trans. Software Eng..

[74]  John A. Zinky,et al.  Architectural Support for Quality of Service for CORBA Objects , 1997, Theory Pract. Object Syst..

[75]  Loe M. G. Feijs,et al.  Test Generation for Intelligent Networks Using Model Checking , 1997, TACAS.

[76]  Walid Taha,et al.  Multi-stage programming with explicit annotations , 1997 .

[77]  Thomas Reps,et al.  Interconveritibility of Set Constraints and Context-Free Language Reachability , 1997, PEPM.

[78]  Ralph E. Johnson,et al.  Components, frameworks, patterns , 1997, SSR '97.

[79]  Orna Kupferman,et al.  Module Checking Revisited , 1997, CAV.

[80]  Tommi Mikkonen,et al.  Formalizing design patterns , 1998, Proceedings of the 20th International Conference on Software Engineering.

[81]  Anneke Kleppe,et al.  The object constraint language: precise modeling with UML , 1998 .

[82]  John A. Zinky,et al.  Specifying and measuring quality of service in distributed object systems , 1998, Proceedings First International Symposium on Object-Oriented Real-Time Distributed Computing (ISORC '98).

[83]  K. Rustan M. Leino,et al.  Extended static checking , 1998, PROCOMET.

[84]  Thomas A. Henzinger,et al.  You Assume, We Guarantee: Methodology and Case Studies , 1998, CAV.

[85]  Alan W. Brown,et al.  The Current State , 2016 .

[86]  Thomas A. Henzinger,et al.  MOCHA: Modularity in Model Checking , 1998, CAV.

[87]  Stephen H. Edwards,et al.  A framework for detecting interface violations in component-based software , 1998, Proceedings. Fifth International Conference on Software Reuse (Cat. No.98TB100203).

[88]  Greg Nelson,et al.  Wrestling with rep exposure , 1998 .

[89]  André Spiegel,et al.  Barat - a front end for java , 1998 .

[90]  Jan Vitek,et al.  Flexible Alias Protection , 1998, ECOOP.

[91]  Martin Gogolla,et al.  Equivalence Rules for UML Class Diagrams , 1998 .

[92]  Clemens A. Szyperski,et al.  Component software - beyond object-oriented programming , 2002 .

[93]  Andy S. Evans,et al.  Reasoning with UML class diagrams , 1998, Proceedings. 2nd IEEE Workshop on Industrial Strength Formal Specification Techniques.

[94]  Kevin Lano,et al.  Semantics and Transformations for UML Models , 1998, UML.

[95]  Andrew Duncan,et al.  Adding Contracts to Java with Handshake , 1998 .

[96]  Emil Sekerinski,et al.  A Study of The Fragile Base Class Problem , 1998, ECOOP.

[97]  Thomas W. Reps,et al.  Program analysis via graph reachability , 1997, Inf. Softw. Technol..

[98]  Jeffrey M. Voas,et al.  Certifying Off-the-Shelf Software Components , 1998, Computer.

[99]  Angelo Gargantini,et al.  Using model checking to generate tests from requirements specifications , 1999, ESEC/FSE-7.

[100]  Michael Huth,et al.  Assume-Guarantee Model Checking of Software: A Comparative Case Study , 1999, SPIN.

[101]  William G. Griswold,et al.  Dynamically discovering likely program invariants to support program evolution , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[102]  Armin Biere,et al.  Symbolic Model Checking without BDDs , 1999, TACAS.

[103]  Mihalis Yannakakis,et al.  Black Box Checking , 1999 .

[104]  Wei-Tek Tsai,et al.  Testing extensible design patterns in object-oriented frameworks through scenario templates , 1999, Proceedings. Twenty-Third Annual International Computer Software and Applications Conference (Cat. No.99CB37032).

[105]  Graham Dunn,et al.  UNDER THE COVERS , 1999 .

[106]  Martin Fowler,et al.  Refactoring - Improving the Design of Existing Code , 1999, Addison Wesley object technology series.

[107]  Holger H. Hoos.  SAT-Encodings, Search Space Structure, and Local Search Performance , 1999, IJCAI.

[108]  Bruce W. Weide,et al.  Experience report: using RESOLVE/C++ for commercial software , 2000, SIGSOFT '00/FSE-8.

[109]  Claude Caci,et al.  Testing object-oriented systems , 2000, SOEN.

[110]  Safely creating correct subclasses without seeing superclass code , 2000, OOPSLA '00.

[111]  James C. Corbett,et al.  Bandera: extracting finite-state models from Java source code , 2000, ICSE.

[112]  Emden R. Gansner,et al.  An open graph visualization system and its applications to software engineering , 2000 .

[113]  Stephen S. Yau,et al.  Integration in component-based software development using design patterns , 2000, Proceedings 24th Annual International Computer Software and Applications Conference. COMPSAC2000.

[114]  Fred B. Schneider,et al.  Enforceable security policies , 2000, TSEC.

[115]  Gregory Kulczycki,et al.  Reasoning about Software-Component Behavior , 2000, ICSR.

[116]  William R. Bush,et al.  A static analyzer for finding dynamic programming errors , 2000 .

[117]  Paul Barry,et al.  Programming Perl 3rd Edition , 2000 .

[118]  Klaus Havelund,et al.  Model checking JAVA programs using JAVA PathFinder , 2000, International Journal on Software Tools for Technology Transfer.

[119]  Alessandro Orso,et al.  Component Metadata for Software Engineering Tasks , 2000, EDO.

[120]  Daniel Jackson,et al.  Finding bugs with a constraint solver , 2000, ISSTA '00.

[121]  Matthias Felleisen,et al.  Behavioral contracts and behavioral subtyping , 2001, ESEC/FSE-9.

[122]  Armando Tacchella,et al.  Benefits of Bounded Model Checking at an Industrial Setting , 2001, CAV.

[123]  M. Moskewicz,et al.  Chaff: engineering an efficient SAT solver , 2001, Proceedings of the 38th Design Automation Conference (IEEE Cat. No.01CH37232).

[124]  Bruce W. Weide,et al.  Specification and Verification with References , 2001 .

[125]  Matthias Felleisen,et al.  Contract Soundness for object-oriented languages , 2001, OOPSLA '01.

[126]  Michael I. Schwartzbach,et al.  The pointer assertion logic engine , 2000, PLDI '01.

[127]  Matthew B. Dwyer,et al.  Finding Feasible Counter-examples when Model Checking Abstracted Java Programs , 2001, TACAS.

[128]  Erik Ernst,et al.  Family Polymorphism , 2001, ECOOP.

[129]  Jean-Marc Jézéquel,et al.  Refactoring UML Models , 2001, UML.

[130]  William G. Griswold,et al.  An Overview of AspectJ , 2001, ECOOP.

[131]  Finn V. Jensen,et al.  Bayesian Networks and Decision Graphs , 2001, Statistics for Engineering and Information Science.

[132]  Robert DeLine,et al.  Enforcing high-level protocols in low-level software , 2001, PLDI '01.

[133]  Thomas A. Henzinger,et al.  Interface automata , 2001, ESEC/FSE-9.

[134]  Klara Nahrstedt,et al.  QoS-aware middleware for ubiquitous computing , 2001 .

[135]  Gregory Kulczycki,et al.  Performance specification of software components , 2001, SSR '01.

[136]  Michael D. Ernst,et al.  Static verification of dynamically detected program invariants: Integrating Daikon and ESC/Java , 2001, RV@CAV.

[137]  David LeBlanc,et al.  Writing Secure Code , 2001 .

[138]  Sarfraz Khurshid,et al.  TestEra: a novel framework for automated testing of Java programs , 2001, Proceedings 16th Annual International Conference on Automated Software Engineering (ASE 2001).

[139]  Carlo Ghezzi,et al.  Using symbolic execution for verifying safety-critical systems , 2001, ESEC/FSE-9.

[140]  M. Sitaraman.  Compositional Performance Reasoning , 2001 .

[141]  Andreas Kaiser.  A SAT-based propositional prover for consistency checking of automotive product data , 2001 .

[142]  Armin Biere,et al.  Bounded Model Checking Using Satisfiability Solving , 2001, Formal Methods Syst. Des..

[143]  Liqing Wang,et al.  A formal approach to component-based software engineering: education and evaluation , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[144]  Sriram K. Rajamani,et al.  The SLAM Toolkit , 2001, CAV.

[145]  Sarfraz Khurshid,et al.  Korat: automated testing based on Java predicates , 2002, ISSTA '02.

[146]  Robert Balzer.  Living with COTS , 2002, ICSE '02.

[147]  Richard Sharp,et al.  Abstracting application-level web security , 2002, WWW.

[148]  Martin C. Rinard,et al.  ACM Conference on Object-Oriented Programming, Systems, Languages and Applications (OOPSLA), November 2002 Ownership Types for Safe Programming: Preventing Data Races and Deadlocks , 2022 .

[149]  Reinhard Wilhelm,et al.  Parametric shape analysis via 3-valued logic , 2002, TOPL.

[150]  Thomas A. Henzinger,et al.  Interface Compatibility Checking for Software Modules , 2002, CAV.

[151]  Ian Gorton,et al.  Software component quality assessment in practice: successes and practical impediments , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[152]  J. Saxe,et al.  Extended static checking for Java , 2002, PLDI '02.

[153]  Kevin J. Compton,et al.  A toolset for supporting UML static and dynamic model checking , 2002, Proceedings 26th Annual International Computer Software and Applications.

[154]  Michael D. Ernst,et al.  Invariant inference for static checking: an empirical evaluation , 2002, SOEN.

[155]  Matt Bishop,et al.  Computer Security: Art and Science , 2002 .

[156]  Alberto L. Sangiovanni-Vincentelli,et al.  Convertibility verification and converter synthesis: two faces of the same coin , 2002, ICCAD 2002.

[157]  Gary T. Leavens,et al.  A Simple and Practical Approach to Unit Testing: The JML and JUnit Way , 2002, ECOOP.

[158]  Deepak Goyal,et al.  Deriving specialized program analyses for certifying component-client conformance , 2002, PLDI '02.

[159]  Sarfraz Khurshid,et al.  An analyzable annotation language , 2002, OOPSLA '02.

[160]  Amnon H Eden.  A VISUAL FORMALISM FOR OBJECT-ORIENTED ARCHITECTURE , 2002 .

[161]  Eugene Goldberg,et al.  BerkMin: A Fast and Robust Sat-Solver , 2002 .

[162]  Kathi Fisler,et al.  Verifying cross-cutting features as open systems , 2002, SIGSOFT '02/FSE-10.

[163]  Ian T. Foster,et al.  Grid Services for Distributed System Integration , 2002, Computer.

[164]  Daniel Jackson,et al.  Alloy: a lightweight object modelling notation , 2002, TSEM.

[165]  Jürgen M. Schneider,et al.  Detection of dynamic execution errors in IBM system automation's rule-based expert system , 2002, Inf. Softw. Technol..

[166]  Monica S. Lam,et al.  Automatic extraction of object-oriented component interfaces , 2002, ISSTA '02.

[167]  Michael Atighetchi,et al.  Packaging quality of service control behaviors for reuse , 2002, Proceedings Fifth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing. ISIRC 2002.

[168]  Alex Groce,et al.  AMC: An Adaptive Model Checker , 2002, CAV.

[169]  K. Rustan M. Leino,et al.  Using data groups to specify and check side effects , 2002, PLDI '02.

[170]  Bruce W. Weide.  Component‐Based Systems , 2002 .

[171]  Gregor Kiczales,et al.  Design pattern implementation in Java and aspectJ , 2002, OOPSLA '02.

[172]  George S. Avrunin,et al.  PROPEL: an approach supporting property elucidation , 2002, ICSE '02.

[173]  Sarfraz Khurshid,et al.  Generalized Symbolic Execution for Model Checking and Testing , 2003, TACAS.

[174]  M. Sitaraman,et al.  Modular Verification of Performance Constraints , 2003 .

[175]  Javier Esparza,et al.  Model checking LTL with regular valuations for pushdown systems , 2001, Inf. Comput..

[176]  Gregory Kulczycki,et al.  Component Technology for Pointers: Why and How , 2003 .

[177]  Augusto Sampaio,et al.  A Refinement Algebra for Object-Oriented Programming , 2003, ECOOP.

[178]  Andrea Polini,et al.  A framework for component deployment testing , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[179]  David Notkin,et al.  Mutually Enhancing Test Generation and Specification Inference , 2003, FATES.

[180]  Doron A. Peled,et al.  Model Checking and Testing Combined , 2003, ICALP.

[181]  Jürgen Dingel,et al.  Computer-assisted assume/guarantee reasoning with VeriSoft , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[182]  Gary T. Leavens,et al.  Modular specification of frame properties in JML , 2003, Concurr. Comput. Pract. Exp..

[183]  Yoonsik Cheon,et al.  A Runtime Assertion Checker for the Java Modeling Language (JML) , 2003, ICSE 2003.

[184]  Shih-Kun Huang,et al.  Web application security assessment by fault injection and behavior monitoring , 2003, WWW '03.

[185]  Durga P. Gandi,et al.  The Humane Bugfinder : Modular Static Analysis Using a SAT Solver , 2003 .

[186]  Joseph Gil,et al.  Revealing class structure with concept lattices , 2003, 10th Working Conference on Reverse Engineering, 2003. WCRE 2003. Proceedings..

[187]  Sarfraz Khurshid,et al.  A Case for Efficient Solution Enumeration , 2003, SAT.

[188]  David Garlan,et al.  A compositional formalization of connector wrappers , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[189]  Edwin D. Reilly.  No-op , 2003 .

[190]  Steven David Prestwich,et al.  Local Search on SAT-encoded Colouring Problems , 2003, SAT.

[191]  Precise analysis of string expressions , 2003 .

[192]  Stephen McCamant,et al.  Predicting problems caused by component upgrades , 2003, ESEC/FSE-11.

[193]  Bertrand Meyer,et al.  The grand challenge of trusted components , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[194]  Nikolai Tillmann,et al.  Serious Specification for Composing Components , 2003 .

[195]  Michael D. Ernst.  Static and dynamic analysis: synergy and duality , 2003 .

[196]  P. S. Thiagarajan,et al.  Message Sequence Charts , 2003, UML for Real.

[197]  Frank Eliassen,et al.  Supporting timeliness and accuracy in distributed real-time content-based video analysis , 2003, MULTIMEDIA '03.

[198]  Paulo Borba,et al.  A UML Class Diagram Analyzer , 2004 .

[199]  Paulo Borba,et al.  An equivalence notion of object models , 2004 .

[200]  Angelos D. Keromytis,et al.  SQLrand: Preventing SQL Injection Attacks , 2004, ACNS.

[201]  David Notkin,et al.  Rostra: a framework for detecting redundant object-oriented unit tests , 2004 .

[202]  Paulo Borba,et al.  Basic Laws of Object Modeling , 2004 .

[203]  Stephen N. Freund,et al.  Atomizer: a dynamic atomicity checker for multithreaded programs , 2004, 18th International Parallel and Distributed Processing Symposium, 2004. Proceedings..

[204]  K. Rustan M. Leino,et al.  The Spec# Programming System: An Overview , 2004, CASSIS.

[205]  Paulo Borba,et al.  Refactoring Alloy Specifications , 2004, Electron. Notes Theor. Comput. Sci..

[206]  Static checking of dynamically generated queries in database applications , 2004, ICSE 2004.

[207]  Gregory Kulczycki,et al.  Direct reasoning , 2004 .

[208]  Augusto Sampaio,et al.  Class and Capsule Refinement in UML for Real Time , 2004, WMF.

[209]  K. Rustan M. Leino,et al.  Modular verification of global module invariants in object-oriented programs , 2004 .

[210]  Susan Owicki,et al.  An axiomatic proof technique for parallel programs I , 1976, Acta Informatica.

[211]  Joël Ouaknine,et al.  State/Event-Based Software Model Checking , 2004, IFM.

[212]  K. Rustan M. Leino,et al.  Object Invariants in Dynamic Contexts , 2004, ECOOP.

[213]  D. T. Lee,et al.  Securing web application code by static analysis and runtime protection , 2004, WWW '04.

[214]  Jakob Rehof,et al.  Summarizing procedures in concurrent programs , 2004, POPL.

[215]  David Notkin,et al.  Automatic Extraction of Object-Oriented Observer Abstractions from Unit-Test Executions , 2004, ICFEM.

[216]  Natasha Sharygina,et al.  Overview of ComFoRT: A Model Checking Reasoning Framework , 2004 .

[217]  Tao Xie,et al.  Improving Generation of Object-Oriented Test Suites by Avoiding Redundant Tests , 2004 .

[218]  Klaus Havelund,et al.  Model Checking Programs , 2004, Automated Software Engineering.

[219]  Paola Inverardi,et al.  Correct Components Assembly for a Product Data Management Cooperative System , 2004, CBSE.

[220]  David Evans,et al.  Dynamically inferring temporal properties , 2004, PASTE.

[221]  Neelam Soundarajan,et al.  Responsibilities and rewards: specifying design patterns , 2004, Proceedings. 26th International Conference on Software Engineering.

[222]  Michael Barnett,et al.  Friends Need a Bit More: Maintaining Invariants Over Shared State , 2004, MPC.

[223]  Jonathan Aldrich,et al.  Open Modules: A Proposal for Modular Reasoning in Aspect-Oriented Programming , 2004 .

[224]  Emina Torlak,et al.  Faster constraint solving with subtypes , 2004, ISSTA '04.

[225]  Edsger W. Dijkstra,et al.  Hierarchical ordering of sequential processes , 1971, Acta Informatica.

[226]  Gregory Kulczycki,et al.  Clean Semantics for Calls with Repeated Arguments , 2005 .

[227]  Stephen H. Edwards,et al.  Model variables: cleanly supporting abstraction in design by contract , 2005, Softw. Pract. Exp..

[228]  Bengt Jonsson,et al.  Insights to Angluin's Learning , 2005, SVV@ICLP.

[229]  David Detlefs,et al.  Simplify: a theorem prover for program checking , 2005, JACM.

[230]  Lars Ole Andersen,et al.  Program Analysis and Specialization for the C Programming Language , 2005 .