Design patterns are distilled from many real systems to catalog common programming practice. We have analyzed several published design patterns and looked for patterns of working around constraints of the implementation language. Some object-oriented design patterns are distorted or overly complicated because of the lack of supporting language constructs or mechanisms. Welay a groundwork of generalpurpose language constructs and mechanisms that, if provided by a statically typed, object-oriented language, would better support the implementation of design patterns and, thus, benefit the construction of many real systems. In particular, our catalog of language constructs includes subtyping separate from inheritance, lexically scoped closure objects independent of classes, and multimethod dispatch. The proposed constructs and mechanisms are not radically new, but rather are adopted from a varietyof languages and combined in a new, orthogonal manner. We argue that by describing design patterns in terms of the proposed constructs and mechanisms, pattern descriptions become simpler and, therefore, accessible to a larger number of language communities. Constructs and mechanisms lacking in a particular language can be implemented using paradigmatic idioms.

Abstract. Modern programming languages have little or no support for querying objects and collections. Programmers are forced to hand code such queries using nested loops, which is both cumbersome and inefficient. We demonstrate that first-class queries over objects and collections improve program readability, provide good performance and are applicable to a large number of common programming problems. We have developed a prototype extension to Java which tracks all objects in a program using AspectJ and allows first-class queries over them in the program. Our experimental findings indicate that such queries can be significantly faster than common programming idioms and within reach of hand optimised queries. 1

Although it is acknowledged that internal iterators are easier and safer to use than conventional external iterators, it is commonly assumed that they are not applicable in languages without builtin support for closures and that they are less flexible than external iterators. We present an iteration framework that uses objects to emulate closures, separates structure exploration and data consumption, and generalizes on folding, thereby invalidating both the above statements. Our proposed "transfold" scheme allows processing one or more data structures simultaneously without exposing structure representations and without writing explicit loops. We show that the use of two functional concepts (function parameterization and lazy evaluation) within an object-oriented language allows combining the safety and economic usage of internal iteration with the flexibility and client control of external iteration. Sample code is provided using the statically typed EIFFEL language.

SYNTAX 3 P \Gamma! skip j true j false j n j self j arg j new ff j x j store x P \Gamma! P ; P j P else P j while P do P j m(P ) Figure 2: Abstract syntax of simple and compound programs only to distinguish instances of the class. For example, the vertices corresponding to instances of class ff are (ff; 0); (ff; 1); : : : . The partial function E defines the edges of the graph. If there is an edge from u to v with label x, then E(u; x) = v. In this case, we may also write (u; x; v) 2 E. Otherwise, E is undefined. We use the symbol "y" to define modified edge functions. If E 0 = E y (v; y; w) then E 0 (u; x) = ae w; if u = v and x = y, E(u; x); otherwise. A state is a tuple (V; E; c; a; r) in which V ` V is a finite set of vertices, E: V \Theta L * V is the edge function, c 2 V is the current vertex, a 2 V is the argument vertex, and r 2 V is the result vertex. [?] We require the set of vertices to be finite for two reasons. First, only a finite number of vertices can be c...