A general incremental evaluator for attribute grammars
Science of Computer Programming
Tentative steps toward a development method for interfering programs
ACM Transactions on Programming Languages and Systems (TOPLAS)
Deriving specifications from requirements: an example
Proceedings of the 17th international conference on Software engineering
Four dark corners of requirements engineering
ACM Transactions on Software Engineering and Methodology (TOSEM)
Augmenting Parsers to Support Incrementality
Journal of the ACM (JACM)
ACM Transactions on Programming Languages and Systems (TOPLAS)
On the criteria to be used in decomposing systems into modules
Communications of the ACM
An Overview of Formal Verification for the Time-Triggered Architecture
FTRTFT '02 Proceedings of the 7th International Symposium on Formal Techniques in Real-Time and Fault-Tolerant Systems: Co-sponsored by IFIP WG 2.2
Model-Checking Algorithms for Continuous-Time Markov Chains
IEEE Transactions on Software Engineering
PRISM 2.0: A Tool for Probabilistic Model Checking
QEST '04 Proceedings of the The Quantitative Evaluation of Systems, First International Conference
QEST '05 Proceedings of the Second International Conference on the Quantitative Evaluation of Systems
Foundations of incremental aspect model-checking
ACM Transactions on Software Engineering and Methodology (TOSEM)
Principles of Model Checking (Representation and Mind Series)
Principles of Model Checking (Representation and Mind Series)
A journey to highly dynamic, self-adaptive service-based applications
Automated Software Engineering
Probabilistic Reachability for Parametric Markov Models
Proceedings of the 16th International SPIN Workshop on Model Checking Software
A model of large program development
IBM Systems Journal
Reasoning on Non-Functional Requirements for Integrated Services
RE '09 Proceedings of the 2009 17th IEEE International Requirements Engineering Conference, RE
The disappearing boundary between development-time and run-time
Proceedings of the FSE/SDP workshop on Future of software engineering research
Run-time efficient probabilistic model checking
Proceedings of the 33rd International Conference on Software Engineering
A compositional method for reliability analysis of workflows affected by multiple failure modes
Proceedings of the 14th international ACM Sigsoft symposium on Component based software engineering
Symbolic and parametric model checking of discrete-time markov chains
ICTAC'04 Proceedings of the First international conference on Theoretical Aspects of Computing
Incremental algorithms for inter-procedural analysis of safety properties
CAV'05 Proceedings of the 17th international conference on Computer Aided Verification
Assume-Guarantee verification for probabilistic systems
TACAS'10 Proceedings of the 16th international conference on Tools and Algorithms for the Construction and Analysis of Systems
A conceptual framework for adaptation
FASE'12 Proceedings of the 15th international conference on Fundamental Approaches to Software Engineering
Self-adaptive software needs quantitative verification at runtime
Communications of the ACM
An incremental verification framework for component-based software systems
Proceedings of the 16th International ACM Sigsoft symposium on Component-based software engineering
| Hi-index | 0.00 |
Software is constantly evolving. Evolution becomes necessary to respond to changes that may occur in the requirements and/or in the environment in which it is embedded. A consequence of changes is that several activities (such as analysis, verification, code generation, deployment) need to be redone, over and over. This paper focuses on verification. Incrementality comes into play because often changes are local to restricted parts. In order to save time, it would be beneficial if instead of redoing activities from scratch after each change, the results of previous processing may be reused and composed with the results of processing restricted portions of the changed software. Incrementality becomes even more necessary when changes occur at runtime and the software itself is responsible for reacting in a self-managed manner. In this setting, the processing that needs to be performed after each change is subject to severe time constraints. The paper is a position statement on incrementality in the context of self-adaptive systems. It starts by motivating the need for incrementality and then reviews three main approaches to incremental verification that have been proposed earlier, compares their potential, and outlines promising research directions.