introduc e a notion of guarded rec ursive (g.r.) datatype c#w struc tors, generalizing the notion ofrec# rsive datatypes in func tional programming languages suc h as ML and Haskell. We address both theoret ic#t and prac# ic## issues resulted from this generalization. On one hand, we design a type system to formalize the notion of g.r. datatypec onstruc - tors and then prove the soundness of the type system. On the other hand, we present some signific ant applic ations (e.g., implementing objec ts, implementing stagedc omputation, etc# ) of g.r. datatype c# nstruc#S rs, arguing that g.r. datatypec onstruc torsc an have far-reac hingc onsequenc es in programming. The mainc ontribution of the paper lies in the rec#I0 ition and then the formalization of a programming notion that is of both theoretic# l interest and prac tic# l use.

The wide practice of objected oriented programming (OOP) in current software practice is evident. Despite extensive studies on typing programming objects, it is still undeniably a challenging research task to design a type system that can satisfactorily account for a variety of features (e.g., binary methods and multiple inheritance) in OOP. In this paper, we present a typeful approach to implementing objects that makes use of a recently introduced notion of guarded datatypes. In particular, we demonstrate how the feature of multiple inheritance can be supported with this approach, presenting a simple and general account for multiple inheritance in a typeful manner.

Abstract not found

Families of independent classes, where each class represents a separate, orthogonal concern are highly attractive for implementing collaboration-based design. However, required subtype relationship between such families cannot be expressed in many programming languages.

The wide practice of object-oriented programming in current software construction is evident. Despite extensive studies on typing programming objects, it is still undeniably a challenging research task to design a type system for objectoriented programming that is both e#ective in capturing program errors and unobtrusive to program construction. In this paper, we present a novel approach to typing objects that makes use of a recently invented notion of guarded dependent datatypes. We show that our approach can address various di#cult issues (e.g., handling "self " type, typing binary methods, etc.) in a simple and natural type-theoretical manner, remedying the deficiencies in many existing approaches to typing objects.

We report on an ongoing project to design a strongly typed, class-based objectoriented language based around ideas from game semantics. Part of our goal is to create a powerful modern programming language whose clean semantic basis renders it amenable to work in program verification; however, we argue that our semantically inspired approach also yields benefits of more immediate relevance to programmers, such as expressive new language constructs and novel type systems for enforcing security properties of the language. We describe a simple-minded game model with a rich mathematical structure, and explain how this model may be used to guide the design of our language. We then focus on three specific areas where our approach appears to offer something new: linear types and continuations; observational equivalence for class types; and static control of the use of higher-order store. In a substantial appendix, we present the formal definition of a fragment of our language which embodies many of the innovative features of the full language. 1 Introduction and

Object types are abstract specifications of object behaviors; object behaviors are abstractly indicated by object component interdependencies; and program verifications are based on object behaviors. In conventional object type systems, object component interdependencies are not taken into account. As a result, distinct behaviors of objects are confused in conventional object type systems, which can lead to fundamental typing/subtyping loopholes and program verification troubles. In this paper, we first identify a program verification problem which is caused by the loose conventional object typing/subtyping which is in turn caused by the overlooking of object component interdependencies. Then, as a new object typing scheme, we introduce object type graphs (OTG) in which object component interdependencies are integrated into object types. Finally, we show how the problem existing in conventional object type systems can be easily resolved under OTG. 1 Introduction and Related Work Although much of the recent year’s work on object-oriented programming (OOP) has focused

... ein Paradigma der Softwareentwicklung, welches das Erstellen von Software durch das Zusammensetzen modular vorliegender Merkmale ermöglicht. Mit aspektorientierter Programmierung (Aspect-Oriented Programming – AOP) wird das Ziel verfolgt Eigenschaften von Software, die über große Teile des Programmcodes verteilt sind, zu kapseln und von anderen Eigenschaften zu trennen. Beiden Ansätzen ist eines gemein: Die Separate Behandlung der Merkmale einer Software (Separation of Concerns). Dennoch sind die Ansätze in ihrer Umsetzung von Grund auf verschieden und haben sowohl Vor- als auch Nachteile. In dieser Arbeit wird FeatureC++ vorgestellt, eine Umsetzung der FOP für C++, die Elemente der AOP integriert. Es werden zwei Dinge gezeigt: (1) Es ist eine Anwendung der AOP auf merkmalsorientierten Quelltext möglich, und (2) die FOP lässt sich auf Aspekte erweitern. Dabei wird festgestellt, dass beide Ansätze von dieser Kombination profitieren.

Current literature states that the undergraduate curriculum can no longer afford the luxury of a traditional compiler construction course. Nevertheless, there is an increasing need for an understanding of how to design and implement domain-specific languages. This paper presents a modern course in compiler construction, designed to provide a student with the capability of quickly constructing robust processors for a variety of language-related applications.