Abstraction and specification in program development
Abstraction and specification in program development
ICSE '89 Proceedings of the 11th international conference on Software engineering
Using Larch to Specify Avalon/C++ Objects
IEEE Transactions on Software Engineering
Advanced C++ programming styles and idioms
Advanced C++ programming styles and idioms
Design patterns: elements of reusable object-oriented software
Design patterns: elements of reusable object-oriented software
Component-based software using RESOLVE
ACM SIGSOFT Software Engineering Notes
A Practical Approach to Programming With Assertions
IEEE Transactions on Software Engineering
Representation Inheritance: A Safe Form of "White Box" Code Inheritance
IEEE Transactions on Software Engineering
Dynamic Verification of C++ Generic Algorithms
IEEE Transactions on Software Engineering - Special issue on formal methods in software practice
Object-oriented software construction (2nd ed.)
Object-oriented software construction (2nd ed.)
Component software: beyond object-oriented programming
Component software: beyond object-oriented programming
Safe and economical reference-counting in C++
C/C++ Users Journal
Experience report: using RESOLVE/C++ for commercial software
SIGSOFT '00/FSE-8 Proceedings of the 8th ACM SIGSOFT international symposium on Foundations of software engineering: twenty-first century applications
A technique for software module specification with examples
Communications of the ACM
STL tutorial and reference guide, second edition: C++ programming with the standard template library
STL tutorial and reference guide, second edition: C++ programming with the standard template library
Modern C++ design: generic programming and design patterns applied
Modern C++ design: generic programming and design patterns applied
Behavioral contracts and behavioral subtyping
Proceedings of the 8th European software engineering conference held jointly with 9th ACM SIGSOFT international symposium on Foundations of software engineering
The C++ Programming Language
Computer
Making Components Contract Aware
Computer
How Assertions Can Increase Test Effectiveness
IEEE Software
A Simple and Practical Approach to Unit Testing: The JML and JUnit Way
ECOOP '02 Proceedings of the 16th European Conference on Object-Oriented Programming
iContract - The Java(tm) Design by Contract(tm) Tool
TOOLS '98 Proceedings of the Technology of Object-Oriented Languages and Systems
A Framework for Detecting Interface Violations in Component-Based Software
ICSR '98 Proceedings of the 5th International Conference on Software Reuse
Risks and challenges of component-based software development
Communications of the ACM - Program compaction
Adding Contracts to Java with Handshake
Adding Contracts to Java with Handshake
HAIL: a language for easy and correct device access
Proceedings of the 5th ACM international conference on Embedded software
Dynamic instantiation-checking components
Proceedings of the 2006 ACM symposium on Applied computing
An assertion-based verification methodology for system-level design
Computers and Electrical Engineering
Simulation environment for testing and verifying the L4 microkernel mapping database
SEPADS'06 Proceedings of the 5th WSEAS International Conference on Software Engineering, Parallel and Distributed Systems
Concept-based partitioning for large multidomain multifunctional embedded systems
ACM Transactions on Design Automation of Electronic Systems (TODAES)
| Hi-index | 0.00 |
Two kinds of interface contract violations can occur in component-based software: A client component can fail to satisfy a requirement of a component it is using, or a component implementation can fail to fulfill its obligations to the client. The traditional approach to detecting and reporting such violations is to embed assertion checks into component source code, with compile-time control over whether they are enabled. This works well for the original component developers, but it fails to meet the needs of component clients who do not have access to source code for such components. A wrapper-based approach, in which contract checking is not hard-coded into the underlying component but is "layered驴 on top of it, offers several relative advantages. It is practical and effective for C++ classes. Checking code can be distributed in binary form along with the underlying component, it can be installed or removed without requiring recompilation of either the underlying component or the client code, it can be selectively enabled or disabled by the component client on a per-component basis, and it does not require the client to have access to any special tools (which might have been used by the component developer) to support wrapper installation and control. Experimental evidence indicates that wrappers in C++ impose modest additional overhead compared to inlining assertion checks.