Joan Krone

Performance specification of software components

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 reasoning demands that components include performance specifications, in addition to descriptions of functional behavior. Unfortunately, as explained in this paper, classical techniques and notations for performance analysis are either unsuitable or unnatural to capture performance behaviors of generic software components. They fail to work in the presence of parameterization and layering. The paper introduces elements of a compositional approach to performance analysis using a detailed example. It explains that performance specification problems are so basic that there are unresolved research issues to be tackled even for the simplest reusable components. These issues must be tackled by any practical proposal for sound performance reasoning. Only then will software developers be able to engineer new systems by choosing and assembling components that best fit their performance (time and space) requirements.

Building a push-button RESOLVE verifier: Progress and challenges

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 involvement in the verification step. However, the general mathematical developments and results upon which software correctness is based may be established through a separate formal proof process in which proofs might be mechanically checked, but not necessarily automatically generated. While many ideas that could conceivably form the basis for software verification have been known “in principle” for decades, and several tools to support an aspect of verification have been devised, practical fully automated verification of full software behavior remains a grand challenge. This paper explains how RESOLVE takes a step towards addressing this challenge by integrating foundational and practical elements of software engineering, programming languages, and mathematical logic into a coherent framework. Current versions of the RESOLVE verifier generate verification conditions (VCs) for the correctness of component-based software in a modular fashion—one component at a time. The VCs are currently verified using automated capabilities of the Isabelle proof assistant, the SMT solver Z3, a minimalist rewrite prover, and some specialized decision procedures. Initial experiments with the tools and further analytic considerations show both the progress that has been made and the challenges that remain.

Use of laboratories in computer science education: guidelines for good practice: report of the working group on computing laboratories

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 the last three are concerned with implementation. This document is part of a continuing effort that the authors envision will result in a laboratory development manual.

Part III: implementing components in RESOLVE

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 component engineering rationale for some slightly unusual language features.

Formal Program Verification

Using formal program verification, it is possible to prove mathematically and mechanically that software behaves correctly as specified. For verification to scale up to software built from components, components must have formal specifications and the verification process must be modular. Unlike testing that can only reveal the presence of errors, formal varification can guarantee correctness. Keywords: abstraction; assertions; components; formal specification; invariants; languages; modular verification; semantics; software engineering

Teaching Mathematical Reasoning Principles for Software Correctness and Its Assessment

Undergraduate computer science students need to learn analytical reasoning skills to develop high-quality software and to understand why the software they develop works as specified. To accomplish this central educational objective, this article describes a systematic process of introducing reasoning skills into the curriculum and assessing how well students have learned those skills. To facilitate assessment, a comprehensive inventory of principles for reasoning about correctness that captures the finer details of basic skills that students need to learn has been defined and used. The principles can be taught at various levels of depth across the curriculum in a variety of courses. The use of a particular instructional process is illustrated to inculcate reasoning principles across several iterations of a sophomore-level development foundations course and a junior-level software engineering course. The article summarizes how learning outcomes motivated by the inventory of reasoning principles lead to questions that in turn form the basis for a careful analysis of student understanding and for fine-tuning teaching interventions that together facilitate continuous improvements to instruction.

Teaching mathematical reasoning across the curriculum

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 math course from what is used in the CS curriculum, making it seem as though these two areas are not connected. Even when discrete math faculty collaborate with CS course instructors, students may not carry over what they learned into their CS curriculum.

A systematic approach to teaching abstraction and mathematical modeling

The need for undergraduate CS students to create and understand mathematical abstractions is clear, yet these skills are rarely taught in a systematic manner, if they are taught at all. This paper presents a systematic approach to teaching abstraction using rigorous mathematical models and a web-based reasoning environment. It contains a series of representative examples with varying levels of sophistication to make it possible to teach the ideas in a variety of courses, such as introductory programming, data structures, and software engineering. We also present results from our experimentation with these ideas over a 3-year period at our institution in a required course that introduces object-based software development, following CS2.

Mathematical Reasoning in Computing Education: Connecting Math We Teach with Writing Correct Programs (Abstract Only)

Computing students often have difficulty understanding the relevance of the math we teach, though educators appreciate the significance. This BoF will discuss ways to connect this math with what computing students think they should be doing: programming. This BoF will focus on the benefits (and perils) of connecting math to the development of correct programs with the goal of motivating the relevance of the math-related portion of the ACM/IEEE Computer Society CS2013 curriculum. The discussion will continue the spirit and essence held by the math-thinking working group, a distributed working group of approximately 170 people who have been promoting and clarifying the importance of mathematics in computer science education.

A Language for Building Verified Software Components

Safe and secure reuse is only achievable by deploying formally verified software components. This paper presents essential design objectives for languages for building such components and highlights key features in RESOLVE—a prototype for such languages. It explains why the language must include specifications as an integral constituent and must have clean and rich semantics, which preclude unconstrained aliasing and other unwanted side-effects. In order that arbitrarily complex components can be given concise and verification amenable specifications, an adequate language must also include an open-ended mechanism for incorporating additional mathematical theories. Given these essential characteristics, safe and secure reuse cannot be attained within popular languages, such as C++ or Java, either by constraining them or by extending them. Better languages are necessary.