Compilers: principles, techniques, and tools
Compilers: principles, techniques, and tools
The C programming language
Statecharts: A visual formalism for complex systems
Science of Computer Programming
STATEMATE: A Working Environment for the Development of Complex Reactive Systems
IEEE Transactions on Software Engineering
On the development of reactive systems
Logics and models of concurrent systems
Automated assistance for program restructuring
ACM Transactions on Software Engineering and Methodology (TOSEM)
A graphical interval logic for specifying concurrent systems
ACM Transactions on Software Engineering and Methodology (TOSEM)
LCLint: a tool for using specifications to check code
SIGSOFT '94 Proceedings of the 2nd ACM SIGSOFT symposium on Foundations of software engineering
Debugging heterogeneous distributed systems using event-based models of behavior
ACM Transactions on Computer Systems (TOCS)
The STATEMATE semantics of statecharts
ACM Transactions on Software Engineering and Methodology (TOSEM)
Experimentation in software engineering: an introduction
Experimentation in software engineering: an introduction
Concurrency: state models & Java programs
Concurrency: state models & Java programs
Model checking
Bandera: extracting finite-state models from Java source code
Proceedings of the 22nd international conference on Software engineering
The SLAM project: debugging system software via static analysis
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
ESP: path-sensitive program verification in polynomial time
PLDI '02 Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation
An Introduction to Formal Languages and Automata
An Introduction to Formal Languages and Automata
Modeling Reactive Systems with Statecharts: The Statemate Approach
Modeling Reactive Systems with Statecharts: The Statemate Approach
Introduction To Automata Theory, Languages, And Computation
Introduction To Automata Theory, Languages, And Computation
Introduction to Algorithms
Software Metrics: A Rigorous and Practical Approach
Software Metrics: A Rigorous and Practical Approach
Making Components Contract Aware
Computer
Specifying Concurrent Systems with TSL
IEEE Software
An Event-Based Architecture Definition Language
IEEE Transactions on Software Engineering
Preliminary guidelines for empirical research in software engineering
IEEE Transactions on Software Engineering
A Framework for the Detection and Resolution of Aspect Interactions
GPCE '02 Proceedings of the 1st ACM SIGPLAN/SIGSOFT conference on Generative Programming and Component Engineering
A Formal Definition of Crosscuts
REFLECTION '01 Proceedings of the Third International Conference on Metalevel Architectures and Separation of Crosscutting Concerns
ASE '00 Proceedings of the 15th IEEE international conference on Automated software engineering
An interval logic for higher-level temporal reasoning
PODC '83 Proceedings of the second annual ACM symposium on Principles of distributed computing
Using Programmer-Written Compiler Extensions to Catch Security Holes
SP '02 Proceedings of the 2002 IEEE Symposium on Security and Privacy
MOPS: an Infrastructure for Examining Security Properties of Software
MOPS: an Infrastructure for Examining Security Properties of Software
Fluent model checking for event-based systems
Proceedings of the 9th European software engineering conference held jointly with 11th ACM SIGSOFT international symposium on Foundations of software engineering
Composition, reuse and interaction analysis of stateful aspects
Proceedings of the 3rd international conference on Aspect-oriented software development
IWPC '05 Proceedings of the 13th International Workshop on Program Comprehension
Fluent temporal logic for discrete-time event-based models
Proceedings of the 10th European software engineering conference held jointly with 13th ACM SIGSOFT international symposium on Foundations of software engineering
Information hiding interfaces for aspect-oriented design
Proceedings of the 10th European software engineering conference held jointly with 13th ACM SIGSOFT international symposium on Foundations of software engineering
Adding trace matching with free variables to AspectJ
OOPSLA '05 Proceedings of the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Finding application errors and security flaws using PQL: a program query language
OOPSLA '05 Proceedings of the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Relational queries over program traces
OOPSLA '05 Proceedings of the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Adding open modules to AspectJ
Proceedings of the 5th international conference on Aspect-oriented software development
The TXL source transformation language
Science of Computer Programming - The fourth workshop on language descriptions, tools, and applications (LDTA'04)
Checking system rules using system-specific, programmer-written compiler extensions
OSDI'00 Proceedings of the 4th conference on Symposium on Operating System Design & Implementation - Volume 4
IEEE Transactions on Software Engineering
Open modules: modular reasoning about advice
ECOOP'05 Proceedings of the 19th European conference on Object-Oriented Programming
Vibes: A visual language for specifying behavioral requirements of algorithms
Journal of Visual Languages and Computing
Contributions of model checking and CoFI methodology to the development of space embedded software
Empirical Software Engineering
Hi-index | 0.00 |
In event-driven systems, separating the reactive part of software (i.e., event-driven control) from the non-reactive part is a common design practice. The reactive part is typically structured according to the states and transitions of a system, whereas the non-reactive part is typically structured according to the concepts of the application domain (e.g., the services provided by the system). In such systems, the non-reactive part of software stimulates the reactive part with event calls. Whenever the non-reactive part is modified (e.g., during evolution), the existing event calls may become invalid, new event calls may become necessary, and the two parts of software may become incompatible. Manually finding and repairing these types of defects is a time-consuming and error-prone maintenance task. In this article, we present a solution that combines source code model checking and aspect-oriented programming techniques, to reduce the time spent by developers and to automatically find defects, while performing the maintenance task mentioned above. In addition, we present controlled experiments showing that the solution can reduce the time by 75%, and enable the prevention of one defect per 140 lines of source code.