Foundations of incremental aspect model-checking

Programs are increasingly organized around features, which are encapsulated using aspects and other linguistic mechanisms. Despite their growing popularity amongst developers, there is a dearth of techniques for computer-aided verification of programs that employ these mechanisms. We present the theoretical underpinnings for applying model checking to programs (expressed as state machines) written using these mechanisms. The analysis is incremental, examining only components that change rather than verifying the entire system every time one part of it changes. Our technique assumes that the set of pointcut designators is known statically, but the actual advice can vary. It handles both static and dynamic pointcut designators. We present the algorithm, prove it sound, and address several subtleties that arise, including cascading advice application and problems of circular reasoning.

[1]  Giovanni Denaro,et al.  An experience on verification of aspect properties , 2001, IWPSE '01.

[2]  Kathi Fisler,et al.  Modular Verification of Open Features Using Three-Valued Model Checking , 2005, Automated Software Engineering.

[3]  Paulo S. C. Alencar,et al.  Supporting Formal Verification of Crosscutting Concerns , 2001, Reflection.

[4]  Lori A. Clarke,et al.  Flow Analysis for Verifying Specifications of Concurrent and Distributed Software , 1999 .

[5]  Klaus Havelund,et al.  Model checking programs , 2000, Proceedings ASE 2000. Fifteenth IEEE International Conference on Automated Software Engineering.

[6]  Kathi Fisler,et al.  Verifying aspect advice modularly , 2004, SIGSOFT '04/FSE-12.

[7]  Kathi Fisler,et al.  Modular Verification of Open Features Through Three-Valued Model Checking � , 2003 .

[8]  L. Hobson‐Webb,et al.  The more the merrier? , 2008, Muscle & nerve.

[9]  Yuanyuan Song,et al.  Information hiding interfaces for aspect-oriented design , 2005, ESEC/FSE-13.

[10]  Mark Ryan,et al.  Logic in Computer Science: Modelling and Reasoning about Systems , 2000 .

[11]  Rajeev Alur,et al.  Model checking of hierarchical state machines , 2001, SIGSOFT '98/FSE-6.

[12]  Yuri Gurevich,et al.  Logic in Computer Science , 1993, Current Trends in Theoretical Computer Science.

[13]  Gerard J. Holzmann,et al.  SOFTWARE TESTING, VERIFICATION AND RELIABILITY , 2022 .

[14]  Sandeep K. Shukla,et al.  Using Aspect-GAMMA in the design of embedded systems , 2002, Seventh IEEE International High-Level Design Validation and Test Workshop, 2002..

[15]  Pierre Wolper Temporal Logic Can Be More Expressive , 1983, Inf. Control..

[16]  Jörgen Hansson,et al.  Aspect-Level WCET Analyzer: A Tool for Automated WCET Analysis of the Real-Time Software Composed Using Aspect and Components , 2003, WCET.

[17]  Douglas C. Schmidt,et al.  Using Aspect-GAMMA in Design and Verification of Embedded Systems ( Extended Abstract ) , 2002 .

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

[19]  M. Maidi The common fragment of CTL and LTL , 2000, Proceedings 41st Annual Symposium on Foundations of Computer Science.

[20]  Edmund M. Clarke,et al.  Modular Translation of Statecharts to SMV , 2000 .

[21]  Shmuel Katz,et al.  Superimpositions and Aspect-oriented Programming , 2003, Comput. J..

[22]  Robert Bruce Findler,et al.  Modular object-oriented programming with units and mixins , 1998, ICFP '98.

[23]  Hridesh Rajan,et al.  Aspect Reasoning by Reduction to Implicit Invocation , 2004 .

[24]  Thomas A. Henzinger,et al.  Software Verification with BLAST , 2003, SPIN.

[25]  Daniel P. Friedman,et al.  Aspect-Oriented Programming is Quantification and Obliviousness , 2000 .

[26]  Parosh Aziz Abdulla,et al.  Tools and Algorithms for the Construction and Analysis of Systems , 1996, Lecture Notes in Computer Science.

[27]  Monika Maidl,et al.  The Common Fragment of CTL and LTL , 2000, FOCS.

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

[29]  Gregor Kiczales,et al.  A semantics for advice and dynamic join points in aspect-oriented programming , 2001, TOPL.

[30]  Edmund M. Clarke,et al.  Model Checking , 1999, Handbook of Automated Reasoning.

[31]  Pierre Wolper,et al.  Reasoning About Infinite Computations , 1994, Inf. Comput..

[32]  Thomas Ledoux,et al.  Aspect-Oriented Software Development , 2003 .

[33]  Shmuel Katz Aspect Categories and Classes of Temporal Properties , 2006, LNCS Trans. Aspect Oriented Softw. Dev..

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

[35]  Howard Barringer,et al.  Assumption generation for software component verification , 2002, Proceedings 17th IEEE International Conference on Automated Software Engineering,.

[36]  Don S. Batory,et al.  Feature-oriented programming and the AHEAD tool suite , 2004, Proceedings. 26th International Conference on Software Engineering.

[37]  Yvon Savaria,et al.  Aspect partitioning for Hardware Verification Reuse , 2003 .

[38]  Jens Krinke,et al.  Interference Analysis for AspectJ , 2003 .

[39]  Rajeev Alur,et al.  A Temporal Logic of Nested Calls and Returns , 2004, TACAS.

[40]  J. Aldrich Open Modules : Modular Reasoning in Aspect-Oriented Programming , 2004 .

[41]  Yoav Hollander,et al.  The e language: a fresh separation of concerns , 2001, Proceedings Technology of Object-Oriented Languages and Systems. TOOLS 38.

[42]  Mira Mezini,et al.  Aspect-oriented programming and modular reasoning , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[43]  Orna Kupferman,et al.  Module Checking , 1996, Inf. Comput..

[44]  Edmund M. Clarke,et al.  Compositional model checking , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

[45]  K. Mani Chandy,et al.  Proofs of Networks of Processes , 1981, IEEE Transactions on Software Engineering.

[46]  Rémi Douence,et al.  A Framework for the Detection and Resolution of Aspect Interactions , 2002, GPCE.

[47]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[48]  Michael Huth Logic In Computer Science , 1999 .

[49]  Harold Ossher,et al.  Subject-oriented programming: a critique of pure objects , 1993, OOPSLA '93.

[50]  Marcelo Sihman,et al.  Model Checking Applications of Aspects and Superimpositions , 2003 .

[51]  Oege de Moor,et al.  Static analysis of aspects , 2003, AOSD '03.

[52]  Mira Mezini,et al.  Adaptive plug-and-play components for evolutionary software development , 1998, OOPSLA '98.

[53]  Sriram K. Rajamani,et al.  The SLAM project: debugging system software via static analysis , 2002, POPL '02.

[54]  Jim Hugunin,et al.  Advice weaving in AspectJ , 2004, AOSD '04.

[55]  Mitchell Wand A Semantics for Advice and Dynamic Join Points in Aspect-Oriented Programming , 2001, SAIG.

[56]  Don S. Batory,et al.  The design and implementation of hierarchical software systems with reusable components , 1992, TSEM.

[57]  Jacques Julliand,et al.  Modular Verification for a Class of PLTL Properties , 2000, IFM.

[58]  James H. Andrews,et al.  Process-Algebraic Foundations of Aspect-Oriented Programming , 2001, Reflection.

[59]  Barry J. Devereux Compositional reasoning about aspects using alternating-time logic , 2003 .

[60]  Uwe Aßmann,et al.  Invasive Software Composition , 2003, Springer Berlin Heidelberg.

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

[62]  Hidehiko Masuhara,et al.  A Compilation and Optimization Model for Aspect-Oriented Programs , 2003, CC.

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

[64]  Masaaki Mizuno,et al.  Invariant-based specification, synthesis, and verification of synchronization in concurrent programs , 2002, ICSE '02.

[65]  Kathi Fisler,et al.  Modular verification of collaboration-based software designs , 2001, ESEC/FSE-9.

[66]  Naoyasu Ubayashi,et al.  Aspect-oriented programming with model checking , 2002, AOSD '02.

[67]  Patrice Godefroid,et al.  Model checking for programming languages using VeriSoft , 1997, POPL '97.

[68]  Matthew B. Dwyer,et al.  Bandera: extracting finite-state models from Java source code , 2000, Proceedings of the 2000 International Conference on Software Engineering. ICSE 2000 the New Millennium.

[69]  Kathi Fisler,et al.  Parameterized interfaces for open system verification of product lines , 2004 .

[70]  Philippe Schnoebelen,et al.  Temporal logic with forgettable past , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

[71]  Yannis Smaragdakis,et al.  Implementing Layered Designs with Mixin Layers , 1998, ECOOP.

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

[73]  Javier Tuya,et al.  Modular Model Checking of Software Specifications with Simultaneous Environment Generation , 2004, ATVA.

[74]  Rajeev Alur,et al.  Model checking of hierarchical state machines , 1998, TOPL.

[75]  Alex Groce,et al.  Modular verification of software components in C , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[76]  Cristina V. Lopes,et al.  Aspect-Oriented Programming , 1997, ECOOP.

[77]  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.

[78]  Don Batory Feature-oriented programming and the AHEAD tool suite , 2004, ICSE 2004.

[79]  Paul Clements,et al.  Software product lines - practices and patterns , 2001, SEI series in software engineering.