Chair of Software Engineering

This list of available presentation topics is intended to facilitate the job of seminar and conference organizers. Of course new topics come up all the time, but this list can serve as a starting point and has the advantage that the presentations are -- in some form -- ready.

The list covers technical and scientific talks rather than industry courses, although these are available too.

A bio appears at the end, ready for inclusion in talk announcements.

The talks are arranged by area:

Trusted components: concepts and progress report

"Trusted Components" -- reusable components of guaranteed quality -- hold one of the best hopes for significant progress in software engineering. The talk will discuss specific steps towards this goal, some practical, some theoretical, and will report advances in a current project aimed at achieving it, including: an outline of a Component Quality Model, a strategy for proving properties of classes equipped with contracts, and specific mechanisms for important technical issues such as pointer-rich runtime structures.

A Component Quality Model

Certifying components requires a set of precise criteria to assess their quality. At the high end we may wish for components with mathematically proved properties, but this is not applicable to ordinary commercial components (O-O, COM, VBX, EJB, .NET etc.) of which we most of the time don't even have the source. Still, we may be able to evaluate many of their quality characteristics based on available information. The talk presents a detailed model for assessing the quality of practical components along five separate dimensions, with a CMM-like scale within each dimension. The purpose is to arrive at a systematic method of qualifying components, in the interest both of their publishers and of their potential users.

[The next three presentations describe facets of work on proving class correctness. The first presents the general framework, the other two present specific techniques.]

A framework for proving class correctness

I present a general strategy for proving that a class equipped with contracts -- preconditions, postconditions, class invariant -- will actually satisfy these contracts in any execution. The proof framework applies the same reuse principles as the object-oriented method does, by taking advantage of inheritance hierarchies to factor out some of the proof at higher levels of abstraction; then, for any descendant of an abstract class, all that remains to prove is that the implementation is consistent with the abstract model. The examples involve data structure classes but the method appears to be generalizable.

Towards practical class proofs

The method presented here makes it possible to prove the correctness of individual contract-equipped classes. It uses a mix of axiomatic and denotational semantics and takes advantage of object-oriented concepts, in particular the notion of "current object" (or "self") and the prevalence of pointers in the run-time structure. The discussion does not, however, cover inheritance. The use of partial functions, high-level functional operators and variants of function composition leads to a concise semantics. Examples of proofs include list algorithms such as insertion, deletion and reversal.

Model and proofs for pointer structures

One of the trickiest issues in proving properties of programs that may create complex dynamic object structures, like most O-O and component-based applications, is to handle pointer or reference structures propertly. This presentation introduces a general theoretical framework for describing run-time object structures with arbitrary pointer complexity and proving properties of the associated software. The framework also covers properties of memory management for dynamic object structures, in particular dynamic allocation and garbage collection.

The list starts with .NET-related presentations of a general nature, accessible to managers and non-developers, and continues with more technical presentations about .NET.

Web Platform of the Future: the Clash of Titans

The battle-lines are drawn for the critical fight to control the Web development platform of the future. On one side, the Java camp is furbishing its well-established tools. On the other, Microsoft .NET provides a comprehensive array of new solutions. This session explores the competitors involved, describes the strategic components of their technologies, accesses their strengths, and analyzes the Clash of Titans whose outcome will determine the IT industry for the decades to come.

.NET overview

This revised and updated version of the multimedia Bertrand Meyer's .NET training course (also Amazon page) presents the key elements of the .NET framework, explaining the rationale behind them and discussing their implications for software developers.

.NET and the power of multi-language programming

Perhaps the most original aspect of Microsoft's .NET framework, whose basic specification is now an international standard, is its support for accommodating software systems and libraries taking advantage of many different programming languages. The level of interoperability between supported languages, both from Microsoft and from third parties, is remarkable.

.NET provides a new model of component-based development, taking advantage of object technology concepts and making it possible to turn ordinary program elements into full software components at essentially no extra effort. Relying on such concepts as metadata and custom attributes, the model also innovates by freeing the component model from dependencies on implementation languages.

The concept of multi-language programming on .NET and its advantages for programmers have been widely misunderstood, with some authors claiming that "below the cover, it's all one language anyway" or that "nobody needs more than one language". This presentation, based on extensive experience with the framework and multi-language interoperability, shows how to accommodate various languages and explains the results as available to programmers. Topics include the CLS (Common Language Specification), how to provide advanced language features such as multiple inheritance and genericity, levels of language interoperability, differences with the Java approach, application to libraries.

The .NET component model

A major part of .NET is a new model for component-based development that supports a high degree of reuse and software composition through a combination of techniques based on the language-independent notion of metadata. We'll explore explore the concepts of component-based development and the "plumbing-free" .NET techniques for building extensive applications based on the combination from many sources, many areas and many programming languages.

Extracting contracts from .NET components

This presentation, resulting from joint work with Karine Arnout, examines some of the key .NET reusable components (from the Collections library) for hidden contracts. The Design by Contract principles suggest that software elements, especially if they are intended to serve as reusable components, should be designed with the benefit of associated contracts. We looked at .NET components, not explicitly equipped with contracts, to see if implicit contracts are there anyway, and what forms they take -- such as exceptions, comments, documentation elements. We indeed succeeded in identifying extensive "closet contracts" in the libraries examined. We describe the contracts thus identified, present statistics of their presence across the library, introduce contract-equipped variants of the library classes that call the originals after enforcing the contracts, examine how much of the contract extraction process can be carried by automatic tools, and discuss the implications of closet contracts on the process of designing reusable components as well as more general O-O applications.

Design by Contract

Design by Contract offers a systematic way to build reliable software. The practice of equipping classes with contracts -- preconditions, postconditions, class invariants and other specification properties -- has a profound influence on many tasks and issues of software development: building software that is correct by construction; documenting software in an automatic and clear way; debugging, testing, quality assurance; software project management; high-level analysis and design; software evolution; handling of abnormal cases; using inheritance properly. We will review the basic ideas of Design by Contract and study how to apply them in practical software development environments.

A simpler approach to event-driven design

This exploration of abstraction mechanisms both in software construction and in programming language design will examine common approaches to writing event-based applications, specifically the Observer Pattern and the C# delegate mechanism, and propose a simpler approach based on the Eiffel agent and genericity mechanisms.

Concurrent Object-Oriented Programming

Object-oriented programming has been widely applied to sequential programming, but there is no generally accepted model for its extension to concurrent applications, even though there intuitively seems to be a natural connection between objects and concurrency. The SCOOP model for concurrent and distributed computing ("Simple Concurrent Object-Oriented Programming"), as presented in this talk, offers a general framework for a variety of parallelism situations, from distribution to CORBA and threads. It has the advantages of simplicity, limited interference of the concurrency features on the algorithmic component of computation, generality, and support of formal reasoning through the application of Design by Contract principles. This presentation summarizes the principal ideas of the SCOOP model, describes recent enhancements, present the current state of implementation, and discusses possible further work, both theoretical and applied.

Type-safe covariance: Competent compilers can catch all catcalls

For programming flexibility and language expressiveness, it is desirable that an object-oriented programming language should offer a covariant type system, which permits adapting the types of both routine arguments and function results, downward along the inheritance hierarchy of classes. The flexibility and expressiveness have so far come at a double price: a more complex notion of type safety, and the remote but real possibility that "holes" in the type system will cause crashes or other misbehavior in the case of erroneous routine calls known as "catcalls" (where "cat" stands for Changing Availability or Type). Many solutions have been proposed in the past two decades, but none has gained practical acceptance, with the result that all major typed object-oriented languages with the exception of Eiffel enforce a novariant policy.

A recent proposal, devised by a working group of ECMA TC39-TG4, the ECMA Eiffel Standards Committee, appears to provide a simple and effective solution. Showing that it's simple is, of course, subject to how clearly I can present it in the seminar; showing that it's effective awaits confirmation by working implementation, mathematical proof, or both. The advantages over existing proposals informally appear conclusive enough, however, that the group believes this will be the solution. I will explain the slight language adaptations that seem, on paper, to ensure covariant type safety, enabling a compiler to guarantee -- without an undue burden on either programmer convenience or compilation performance -- that object-oriented programs won't ever cause a single new catcall.

Managing object-oriented projects

Based on experience of numerous project, this presentation describes the manager's role in leading an object-oriented development, to gain the most benefit from the technology and avoid typical pitfalls. Topics include: role of the manager, and tasks to avoid; interacting with higher management; metrics; the object-oriented lifecycle; the cluster model; a realistic reuse policy, and how to make it succeed; using the technology well; hiring O-O developers; documentation; evolution; quality assurance.

Agents, iterators, introspection and high-level contracts

A challenge of object-oriented software engineering is to express higher-order computations without violating the rules of static typing. Higher-order operators (operators that work on operators) serve a a number of important applications: expressing powerful iteration mechanisms, especially for libraries; providing introspective (or "reflexive") facilities, enabling programs to look at themselves; writing truly useful contracts for precise specification of classes and their features.

The talk presents a simple and general mechanism, "agent". It describes a number of practical applications and shows how the agent mechanism provides higher-order operators within a strictly static object-oriented type system. Comparisons will be made with other approaches such as function pointers, Java's reflexive mechanisms and .NET "delegates".

Building an application: the GUI and the business model

Rather than a standard research talk this is a partly improvised examination of techniques, as provided in the Eiffel method, for building a GUI application without being constrained by the limitations of either RAD or heavy software processes. A small application will be built interactively using some of the recent tools of the EiffelStudio environment.

Applying Design by Contract in the Eiffel method

Eiffel is the native language of Design by Contract. The method integrates DBC principles in its very fabric, with direct support from the language and tools. Starting from a simple metaphor, these principles give developers and managers a tighter grasp on the systems they develop, with particular benefits for reusable components. We'll see how best to make use of Eiffel language and tool mechanisms to get the full benefit of Design by contract.

Roundtrip engineering with the Eiffel method

Traditional software engineering techniques have introduced gaps between successive activities of software development. The Eiffel method, with its emphasis on full lifecycle coverage and its reliance on the central technique of Design by Contract as a unifying theme for all software activities, provides an integrated approach to activities of analysis, design, implementation and maintenance. This presentation introduces the essential elements of the method and describe the new style of software development made possible by Eiffel's emphasis on seamlessness and reversibility.

Legacy code, object technology and Eiffel

The software world is increasingly multilingual. Well-applied object technology can serve as a powerful interoperability tool, helping developers to reuse, package and combine software elements written in various languages, while preparing the move to new approaches. The talk will concentrate on these benefits of object technology and examine the role of Eiffel in this process, both as an advanced form of object technology and as a packaging technology for integrating existing software and legacy systems. It will particularly address what Eiffel can bring to C, C++ and Java developers, and discuss the new interoperability advances brought by the language interoperability mechanisms of .NET and the integration of Eiffel into both the .NET framework and the Visual Studio .NET development environment.

Recent developments in the Eiffel language

Building on a stable core of basic concepts, the Eiffel language continues to evolve both by simplification, in particular unification of existing constructs, and by the addition of new mechanisms facilitating the use of important design patterns. The aim is to maximize the "signal to noise" ratio of the language, where the "signal" is the expressive power of useful constructs, and the "noise" is language complexity and duplicate forms of expression.

I will describe some of the key recent additions and suppressions of recent years, including agents for integrating descriptions of behavior (as in functional languages) in an O-O framework, tuples, extended forms of genericity, new mechanisms for object creation, advanced contract mechanisms, and other developments intended to improve software quality and productivity.

EiffelStudio and its role in the Eiffel method

The EiffelStudio development environment, directly tailored to the Eiffel method, applies the "Single Product Principle": it treats the software as a single entity, from which it can derive multiple views, more or less abstract, and adapted to various purposes. Two of the principal views are the source text and the graphical view (BON diagrams); EiffelStudio supports full reversibility between the two, so that users can reverse engineer the diagrams from the text, or generate the text from diagrams, or alternate these two modes. Any modification to the diagrams is immediately reflected in the text and conversely. Other views include the "contract form" or high-level interface of the class, the inheritance structure and many others.

We will also explore the "pick-and-drop" browsing mechanisms, the O-O debugging facilities, the Metrics Tool, the editing facilities, and the other mechanisms that provide a comprehensive development environment covering all phases of the lifecycle.

Language description techniques and the ECMA Eiffel standardization process

In April of 2002 the ECMA standards body created a new technical committee, TC39-TG4, to standardize the Eiffel language. The talk presents the current state of this effort and discusses the specific language description mechanisms that the Eiffel reference uses to provide a degree of precision higher than in most similar efforts, especially for static and dynamic semantics.

[See also Trusted Components above.]

The future of component-based development

This talk analyses current advances in the field of component-based software development, the evolution of the major supporting technologies, and possible solutions to the main challenges in this area.

Techniques for building reusable components

Constructing quality components is an art. Reusable software must be very good software, and then it must be usable by many different projects working in highly different conditions. Over the years, we have developed systematic techniques and principles for building libraries of reusable components; components built with these techniques have benefitted numerous projects in diverse application areas.

The techniques and principles, which the talk presents in detail, include: systematic use of Design by Contract; the Open-Closed principle; the Command-Query Separation Principle; the Operand-Option Separation Principle; systematic naming techniques; systematic principles for using single, multiple and repeated inheritance; techniques for classifying and indexing components.

The role of metrics in software development

This survey talk discusses the role and limits of quantitative approaches in software development. It examines various categories of metrics, assessing reliability, cost, complexity and other properties of software processes and products.

Requirements engineering, specification, and formalism

Getting the specification right is one of the key challenges in software development. We study techniques to achieve this goal and discuss in detail how much formality is needed for proper requirements and specification analysis.

The unity of software and the power of roundtrip engineering

Part of the initial progress in developing an engineering basis for software development was to identify the specific tasks at hand and highlight their differences. Although initially justified as a reaction against undisciplined approaches, this trend has sometimes gone too far, obscuring the the fundamental unity of the software construction process and leading to unnecessary gaps between successive phases. This can be harmful to both quality and productivity.

A more effective approach takes take advantage of the fundamental invariants of software development and views system engineering as a continuous, seamless and reversible process.

The talk shows how to implement such roundtrip engineering in practice, and discusses the consequences on both process and product

The next software breakthrough

In its short history, the software world has already experienced a number of breakthroughs: ideas that changed the face of the industry. The talk recalls these breakthroughs and examines two that did not occur. It explains why they are both needed, examine what is required for them to happen, and how their combination will forever change the nature of software development.

Research methods in software engineering

Directed at an audience of researchers such as PhD students, this presentation discusses what's specific about doing research in the software engineering field at large, touching among the following subjects among others: choosing important subjects; various types of research -- conceptual, experimental, analytic; role of mathematics and theory; role of commercial software engineering products; tools vs concepts; pitfalls for the beginning researcher; journals and conferences; refereeing practices and refereeing ethics; role of advisors, peers; implementing software as part of one's research; ethical issues of software engineering research.

Teaching introductory programming: the inverted curriculum

The new wave of computer science students and the new context of computer science education make the first programming course ever more of a challenge. We cannot ignore the previous experiences of our students, but must prepare them for the realities of professional software development. We should, right from the start, instill concepts and principles of software engineering, teaching by example whenever possible. I will describe a comprehensive approach to introductory teaching, under implementation at ETH. The approach takes full advantage of the reusable libraries available in a good object-oriented environment to show the benefits of abstraction through reuse, and lets the students grow progressively from consumers to producers.

Known as the Inverted Curriculum, this approach seeks to bring students, from the earliest stages of their education, the best of modern software technology.

Teaching software engineering

Teaching software engineering in an academic context remains a challenge. Relying on many people's experience of using object technology in the curriculum, the presentation introduces a set of principles and techniques for a modern software curriculum designed to interest the students and provide them with a solid core of life-long skills.

Software engineering in the academy

What is the place of software engineering education and research in a university context? What is unique to our field, and how to we convey it to students and relate it to other academic disciplines?

Bertrand Meyer is Professor of Software Engineering at ETH Zürich, and Founder and Chief Architect of Eiffel Software in California. His books include "Object-Oriented Software Construction", "Reusable Software", "Introduction to the Theory of Programming Languages" and "Eiffel: The Language".