Computer (IEEE), 2006. Abstract: In software design, laziness is a virtue: it’s better to reuse than to redo. Design patterns are a good illustration. Patterns, a major advance in software architecture, provide a common vocabulary and a widely known catalog of design solutions addressing frequently encountered situations. But they do not support reuse, which assumes components: off-the-shelf modules ready to be integrated into an application through the sole knowledge of a program interface (API). Is it possible to go beyond patterns by componentizing them — turning them into components? We have built a component library which answers this question positively for a large subset of the bestknown design patterns. Here we summarize these results and analyze the componentization process through the example of an important pattern, Visitor, showing how to take advantage of object-oriented language mechanisms to replace the design work of using a pattern by mere “ready-to-wear ” reuse through an API. The reusable solution is not only easier to use but more general than the pattern, removing its known limitations; performance analysis on a large industrial application shows that the approach is realistic and scales up gracefully.

This paper proposes that GUI development is as important as other aspects of programming, such as a sound understanding of control structures and object orientation. Far less attention has been paid to the programming structures for GUIs and certainly there are few cross language principles to aid the programmer. We propose that principles of GUIs can be extracted and learnt, and that they do enhance good programming practice. These principles have been implemented in our Views system which features an XML-based GUI description notation coupled with an engine that shields the programmer from much of the intricate complexity associated with events, listeners and handlers. The system is programmed primarily in C # for.NET, but is available in various forms for Java and for other platforms which support.NET through the SSCLI.

In software design, laziness is a virtue: it’s better to reuse than to redo. Design patterns are a good illustration. Patterns, a major advance in software architecture, provide a common vocabulary and a widely known catalog of design solutions addressing frequently encountered situations. But they do not support reuse, which assumes components: off-the-shelf modules ready to be integrated into an application through the sole knowledge of a program interface (API). Is it possible to go beyond patterns by componentizing them — turning them into components? We have built a component library which answers this question positively for a large subset of the bestknown design patterns. Here we summarize these results and analyze the componentization process through the example of an important pattern, Visitor, showing how to take advantage of object-oriented language mechanisms to replace the design work of using a pattern by mere “ready-to-wear ” reuse through an API. The reusable solution is not only easier to use but more general than the pattern, removing its known limitations; performance analysis on a large industrial application shows that the approach is realistic and scales up gracefully.

Abstract. The Event Library is a simple library that provides a solution to the common problems in event-driven programming. Its careful design facilitates further extensions, in order to satisfy users ’ advanced needs. It has been implemented in Eiffel, taking advantage of the advanced mechanisms of this language. In this paper, we present the architecture of the library and show how it can be used for building event-driven software. The discussion is illustrated with a sample application. 1

Can some Design Patterns be turned into reusable components? To help answer this question, we have studied two creational design patterns — the Abstract Factory and the Factory Method patterns — and managed to build a reusable library fulfilling the same needs as the original patterns. This article describes the architecture of the Factory Library and discusses the pros and cons of both approaches using concrete examples.

The Simple Object-Oriented Concurrent Programming (SCOOP) model proposed by Bertrand Meyer and illustrated through the Ei#el programming language is a simple yet powerful model for concurrent programming.

Science of the Departamento de Informática, PUC–Rio as

We introduce a class of program editors that present a program using a rich set of transformations; we call these kinds of editors composable presentation editors. Proper use of these kinds of editors appears to lead to more expressive programs—programs whose structure are aligned with the problem they are trying to solve. By default, the composable presentation editor presents program elements textually as concrete syntax and enables typical editor commands on the program. Metadata on program elements control how the transformations are applied. Customized metadata can re-order, pictorialize, collapse, duplicate, or expand the displayed form of program elements and can additionally alter the available editor commands. We have developed a set of presentation techniques to be used by presentation designers (i.e., the programmers who design how a program is presented in the editor). These techniques relate to well-understood programming language design, editor design, and programming best-practices techniques including scoping, higher order functions, refactoring, prettyprinting, naming conventions, syntax highlighting, and text hovers. We introduce two implementations of composable presentation editors and a number of examples showing how programs can be made more expressive when presentation techniques are properly used. The first implementation is the ETMOP, an open editor, where a metaobject protocol is provided that allows language and editor designers to customize the way program elements are displayed. These customizations are called presentation extensions and the corresponding presentation extension protocol acts in a way similar to the way that syntax macros extend the syntax of a language. The second implementation is Embedded CAL, a closed editor that uses these presentation techniques to embed one language (CAL) inside a host language (Java) through the use of presentation techniques, without changing the syntax or compiler of either language.

se.ethz.ch — www.eiffel.com

The paper considers the problems and the solutions that are concerned with the extension of Java with Higher Order (HO) mechanisms. These mechanisms are typical of functional languages and include higher order abstraction, that makes a Java method parametric with respect to other methods that can be passed as parameters, and code as first class value, that can be assigned to variables, passed as parameter, returned by method invocations,