The final copy of this thesis has been examined by the signatories, and we find that both the content and the form meet acceptable presentation standards of scholarly work in the above mentioned discipline. HRC protocol # 1202.14,

ince 1950, the technology of calculation and data processing

To design a program, first find your objects. Unfortunately, the right objects are not easy to find, and as a result most programs are not as well designed as they could be. This paper presents four patterns which describe how objects can be found within the designs of existing programs. By using these patterns, programs and designs can be made more simple, more general, and more easy to change. Introduction Finding objects is probably the most important part of object oriented design. The patterns in this paper describe one way to find objects --- by examining the design of the program. These patterns address two questions: how can you find objects within a program? and, once you have found some objects, what should you do with them? These patterns do not aim to describe novel research results; rather, they attempt to capture and present well known design techniques, illustrate when particular techniques are applicable, and outline their relative strengths and weaknesses. These patte...

The Lollipop format is a meta-format: it does not define user macros, but it contains the tools with which a style designer can easily implement such user macros. This article will show some of the capabilities of Lollipop and will give the reader a small peek behind the scenes of the implementation. T E X is intended to support higher-level languages for composition Donald Knuth 1 Introduction One of the reasons that T E X is not widely accepted outside the scientific world is that the effort needed to create new visual designs, or even to make minimal modifications of a given design ("this article is a bit too long, but since we have rather generous margins, why don't we put the title in the margin next to the abstract, instead of over it") is disproportionally large. In Eijkhout and Lenstra (1991) it was argued that one way of solving this problem would be to implement powerful tools that a style designer could use to program macros without ever programming in T E X itself. I...

Abstract. Checking consistency between an object diagram (OD) and a class diagram (CD) is an important analysis problem. However, several variations in the semantics of CDs and ODs, as used in different contexts and for different purposes, create a challenge for analysis tools. To address this challenge in this paper we investigate semantically configurable model analysis. We formalize the variability in the languages semantics using a feature model: each configuration that the model permits induces a different semantics. Moreover, we develop a parametrized analysis that can be instantiated to comply with every legal configuration of the feature model. Thus, the analysis is semantically configured and its results change according to the semantics induced by the selected feature configuration. The ideas are implemented using a parametrized transformation to Alloy. The work can be viewed as a case study example for a formal and automated approach to handling semantic variability in modeling languages. “One man’s constant is another man’s variable.” Alan Perlis [21] 1

It’s blatantly clear You stupid machine, that what I tell you is true — Michael Norrish 1 This paper compares three models for formal reasoning about programming languages with binding. Higher order abstract syntax (hoas) uses meta-level binding to represent object-level binding [PE88]. Nominal Logic couples a concrete representation of bound variables with a formal apparatus for safely manipulating bound variables [Pit03]. The locally named binding representation places bound and free variables in different syntactic sorts [MP99]. This paper surveys each binding model, and compares it to the others and to Gordon and Melham’s axiomatization of the untyped lambda calculus [GM97]. Comparisons are made based on expressive power, transparency to human readers, and suitability for mechanized reasoning of each binding model. Each system excels in one area; hoas is most expressive, Nominal Logic most transparent, and locally named most mechanizable. 1

ages a programming language, the usual other slogans of modern software engineering apply. That is, the language must support the writing of programs that are reliable, easily modi#ed, e#cient, machine-independent, and formally describable. A request for proposals produced 15 preliminary language designs. The Defense Department chose four of these for further development. After a twoyear competition, it selected a winner. This language was christened #Ada" in honor of Ada Augusta, Countess of Lovelace, a co-worker of Babbage and the #rst programmer. Ada was created in the limelight. Many members of the academic and industrial computer science community contributed advice and criticism to the development process. The result is a language whose scope is ambitious. SIGPLAN Notices served as a forum for much of the debate surrounding the speci#cation and development process. Ada is at the far language end of the language-model spectrum.* The entire syntax

The Lollipop format is a meta-format: it does not define user macros, but it contains the tools with which a style designer can easily implement such user macros. This article will show some of the capabilities of Lollipop and will give the reader a small peek behind the scenes of the implementation.

The research activities in software engineering at the Center for LifeLong Learning & Design (L3D) in the past have been grounded in the basic assumption that important aspects of software engineering are best understood as human-centered design activities. Some of the major objectives were to support designers with domain-oriented design environments, allowing them to interact at the problem domain level and to frame activities and artifacts based on an evolutionary approach. A fundamental shift occurring over the last few years is the formation of participation cultures enhanced and supported by a change from an industrialized information economy (specialized in producing finished goods to be consumed passively) to a cyber-enabled networked information economy (in which all people are provided with the means to participate actively in personally meaningful problems). Some of the implications of this fundamental shift for software engineering, including meta-design, lessons learned from open source software, and distribution and diversity in communities, are explored, and their implications for the “automate/informate” perspectives are briefly discussed. Keywords software design; domain-oriented design environments; human-problem domain interaction; meta-design; distribution and diversity; networked information economy; participation cultures

Self is a prototype-based programming language, often described as More Smalltalk Than Smalltalk. This paper presents implementations of a selection of the Design Patterns in Self, and investigates the differences between their implementations in Self compared with other object-oriented programming languages.