Learn More
The organization is as follows. First we present some example realization modules with little elaboration. Then we discuss many aspects of realization modules in general, using the examples for illustration. Finally, we give an overview of the basis for modular verification of the correctness of realizations. The focus throughout is on the software(More)
Component-based software engineering is concerned with predictability in both functional and performance behavior, though most formal techniques have typically focused their attention on the former. Reasoning about the (functional or performance) behavior of a component-based system must be compositional in order to be scalable. Compositional performance(More)
Safe and secure reuse demands construction and use of verified reusable software components. Such verified components need much more than typical code for components in popular languages, such as C++ or Java. The components need to have formal specifications of behavior against which their implementations are verified. To be trusted, such verification must(More)
A central objective of the verifying compiler grand challenge is to develop a push-button verifier that generates proofs of correctness in a syntax-driven fashion similar to the way an ordinary compiler generates machine code. The software developer’s role is then to provide suitable specifications and annotated code, but otherwise to have no direct(More)
Modular analysis of performance for component-based systems is the focus of this paper. The paper introduces performance contracts that specify time and space. The contracts are expressed in a modular fashion using a suitable coordinate system that admits the consequences of software engineering tenets such as abstraction and parameterization. The paper(More)
A system for engineering component-based software must include mechanisms for specifying abstractly both the functionality of components and their performance. Using the profile construct introduced here for performance specification, a developer can select from an assortment of implementations for a particular functionality the one that best suits his(More)
We introduce a "hands-on" experimentation approach for teaching mathematical specification and reasoning principles in a software engineering course. The approach is made possible by computer-aided analysis and reasoning tools that help achieve three central software engineering learning outcomes: (i) Learning to read specifications by creating test points(More)
It is all too often the case that CS students learn concepts of mathematical reasoning in a required discrete math course, but fail to apply what they have learned to their CS courses. This may occur because the courses are taught in different departments with little communication between faculty members, so that different terminology may be used in the(More)
This paper explores various aspects of the use of laboratories in teaching Computer Science. The foIlowing six topics are discussed in detail: i scope of courses, ii relationship between lecture and lab, iii pedagogy, iv an Internet repository for laboratory materials, v institutional support and vi technology, The first three items deal with content while(More)
Most computer science departments provide their students with a mathematical foundation which enables them to master theoretic concepts necessary for algorithm analysis, formal specifications of software, reasoning about correctness of software, and classifying problems as solvable or unsolvable. Most departments also require students to design and(More)