Type-theoretic design patterns

1996

Object-oriented programming languages oopl's provide important support for today's large-scale software development projects. Unfortunately, the typing issues arising from the object-oriented features that provide this support are substantially di erent from those that arise in typing procedural languages. Attempts to adapt procedural type systems to object-oriented languages have resulted in languages like Simula, C++, and Object Pascal, which h a v e o v erly restrictive t ype systems. Among other things, the rigidity of these systems frequently force programmers to use type casts, which are a notorious source of hard-to-nd bugs. These restrictive type systems also mean that many programming idioms common to untyped oopl's such as Smalltalk are not typeable. One source of this lack of exibility is the con ation of subtyping and inheritance. Brie y, inheritance is an implementation technique in which new object de nitions may be given as incremental modi cations to existing de nitions. Subtyping concerns substitutivity: when can one object safely replace another? By tying subtyping to inheritance, existing oopl's greatly reduce the number of legal substitutions in a system, and hence their degree of polymorphism. Attempts to x this rigidity h a v e resulted in unsound type systems, most notably Ei el's.

Theory and Practice of Object Systems, 1995

This paper, which is partly tutorial in nature, summarizes some basic research goals in the study and development o f t yped objectoriented programming languages. These include both immediate repairs to problems with existing languages and the long-term development o f more exible and expressive, yet type-safe, approaches to program organization and design. The technical part of the paper is a summary and comparison of three object models from the literature. We conclude by discussing approaches to selected research problems, including changes in the type of a method from super class to sub class and the use of types that give information about the implementations as well as the interfaces of objects. Such implementation types seem essential for adequate typing of binary operations on objects, for example.

2008

We introduce basic concepts from object-oriented programming into dependent type theory based on the idea of modelling objects as interactive programs. We consider methods, interfaces, and the interaction between a fixed number of objects, including self-referential method calls. We introduce a monad like syntax for developing objects in dependent type theory.

Citeseer, 1999

In this thesis we study some object-oriented mechanisms from the type system perspective. Our starting point is the axiomatic model of Fisher, Honsell and Mitchell, the Lambda Calculus of Objects. Following the path of recent researches on the topic, we show how some object-based language features can be happily modeled within some functional calculi, proved sound with respect to the message-not-understood error. Then, we approach the more complicated problem of modeling class constructs, presenting two proposals and discussing their respective qualities and drawbacks, together with some future directions we would like to follow to try to better understand classbased languages. precious comments and all of the discussions we had together on objects. A special thank goes to Betti Venneri (University of Firenze), for her encouragement since she has been the supervisor for my master thesis when she was still in Torino. My gratitude goes then to my external referees, Giuseppe Castagna (ENS, Paris) and Sophia Drossopoulou (Imperial College, London), for their kindness in accepting to read my manuscript and for their precious suggestions that helped me improving the presentation of my work. Last but not least, I would like to mention all the people I met during my academic path that made my life easier with their friendship and their support (following again the temporal order in which I met them for the rst time

2006

Abstract Design patterns are reusable abstractions in object-oriented software. However, using current mainstream programming languages, these elements can only be expressed extra-linguistically: as prose, pictures, and prototypes. We believe that this is not inherent in the patterns themselves, but evidence of a lack of expressivity in the languages of today. We expect that, in the languages of the future, the code parts of design patterns will be expressible as reusable library components.

Software Pioneers, 2002

We propose design patterns as a new mechanism for expressing object-oriented design experience. Design patterns identify, name, and abstract common themes in objectoriented design. They capture the intent behind a design by i d e n tifying objects, their collaborations, and the distribution of responsibilities. Design patterns play many roles in the object-oriented development process: they provide a common vocabulary for design, they reduce system complexity b y naming and de ning abstractions, they constitute a base of experience for building reusable software, and they act as building blocks from which more complex designs can be built. Design patterns can be considered reusable micro-architectures that contribute to an overall system architecture. We describe how to express and organize design patterns and introduce a catalog of design patterns. We also describe our experience in applying design patterns to the design of object-oriented systems.

1995

Journal of Functional Programming, 1994

To illuminate the fundamental concepts involved in object-oriented programming languages, we describe the design of TOOPL, a paradigmatic, statically-typed, functional, object-oriented programming language which supports classes, objects, methods, hidden instance variables, subtypes and inheritance.It has proven to be quite difficult to design such a language which has a secure type system. A particular problem with statically type checking object-oriented languages is designing typechecking rules which ensure that methods provided in a superclass will continue to be type correct when inherited in a subclass. The type-checking rules for TOOPL have this feature, enabling library suppliers to provide only the interfaces of classes with actual executable code, while still allowing users to safely create subclasses. To achieve greater expressibility while retaining type-safety, we choose to separate the inheritance and subtyping hierarchy in the language.The design of TOOPL has been gui...

Journal of the National Science Foundation of Sri Lanka, 2008

Although design patterns are reusable design elements, existing pattern descriptions focus on specific solutions that are not easily reusable in new designs. This paper introduces a new pattern description method for object oriented design patterns. The description method aims at providing a more general description of patterns so that patterns can be readily reusable. This method also helps a programmer to analyze, compare patterns, and detect patterns from existing software programmes. This method differs from the existing pattern description methods in that it captures both static and dynamic properties of patterns. It describes them in terms of mathematical entities rather than natural language narratives, incomplete graphical notations or programme fragments. It also helps users to understand the patterns and relationships between them; and select appropriate patterns to the problem at hand. We also present a case study to demonstrate the methods' suitability for specifying object oriented design patterns.

Programming Languages and Systems, 2004

This paper develops a mathematical characterisation of object-oriented concepts by defining an observation-oriented semantics for an object-oriented language (OOL) with a rich variety of features including subtypes, visibility, inheritance, dynamic binding and polymorphism. The language is expressive enough for the specification of object-oriented designs and programs. We also propose a calculus based on this model to support both structural and behavioural refinement of object-oriented designs. We take the approach of the development of the design calculus based on the standard predicate logic in Hoare and He's Unifying Theories of Programming (UTP). We also consider object reference in terms of object identity as values and mutually dependent methods.