Learn 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)
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)
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)
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)
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)