Hierarchical correctness proofs for distributed algorithms
PODC '87 Proceedings of the sixth annual ACM Symposium on Principles of distributed computing
Proceedings of the 8th European software engineering conference held jointly with 9th ACM SIGSOFT international symposium on Foundations of software engineering
Making Components Contract Aware
Computer
Behavior Protocols for Software Components
IEEE Transactions on Software Engineering
Advanced Thread Synchronization in Java Using Interaction Expressions
NODe '02 Revised Papers from the International Conference NetObjectDays on Objects, Components, Architectures, Services, and Applications for a Networked World
11th OOPSLA workshop on behavioral semantics: serving the customer
OOPSLA '02 Companion of the 17th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Specifying and checking method call sequences of Java programs
Software Quality Control
Detecting object usage anomalies
Proceedings of the the 6th joint meeting of the European software engineering conference and the ACM SIGSOFT symposium on The foundations of software engineering
A java implementation of a component model with explicit symbolic protocols
SC'05 Proceedings of the 4th international conference on Software Composition
Towards architecture-centric evolution of long-living systems (the ADVERT approach)
Proceedings of the 9th international ACM Sigsoft conference on Quality of software architectures
| Hi-index | 0.01 |
Many software systems are stateful or have stateful components, i.e. they manage and process data depending on certain steps performed before. For this reason, sequential contracts are of interest that describe component interfaces with respect to sequences of invocations leaving the component in a valid state. While sophisticated models for this purpose exist, component frameworks don't support sequential contracts, so that a validation of the state is performed algorithmically and mixed-up with application logic in method contents. In this contribution we present (1) meta data for object-oriented program code that allow to annotate component interfaces with sequential contracts and (2) a pattern and tools integrating sequential contracts in Java Enterprise components. The contracts can then be modeled as part of the program code at development time and be interpreted at run time to prevent invalid method invocations and provide tracing data in case of errors.