Results 1 - 10
of
16
A typed, compositional logic for a stack-based abstract machine
- In Proc. 3rd Asian Symposium on Programming Languages and Systems (APLAS), volume 3780 of Lecture Notes in Computer Science
, 2005
"... Abstract. We define a compositional program logic in the style of Floyd and Hoare for a simple, typed, stack-based abstract machine with unstructured control flow, global variables and mutually recursive procedure calls. Notable features of the logic include a careful treatment of auxiliary variable ..."
Abstract
-
Cited by 21 (6 self)
- Add to MetaCart
Abstract. We define a compositional program logic in the style of Floyd and Hoare for a simple, typed, stack-based abstract machine with unstructured control flow, global variables and mutually recursive procedure calls. Notable features of the logic include a careful treatment of auxiliary variables and quantification and the use of substructural typing to permit local, modular reasoning about program fragments. Semantic soundness is established using an interpretation of types and assertions defined by orthogonality with respect to sets of contexts. 1
Lost in Translation: Formalizing Proposed Extensions to C
- In OOPSLA ’07: Proceedings of the 22nd annual ACM SIGPLAN conference on Object
, 2007
"... Current real-world software applications typically involve heavy use of relational and XML data and their query languages. Unfortunately object-oriented languages and database query languages are based on different semantic foundations and optimization strategies. The resulting “ROX (Relations, Obje ..."
Abstract
-
Cited by 21 (3 self)
- Add to MetaCart
Current real-world software applications typically involve heavy use of relational and XML data and their query languages. Unfortunately object-oriented languages and database query languages are based on different semantic foundations and optimization strategies. The resulting “ROX (Relations, Objects, XML) impedance mismatch ” makes life very difficult for developers. Microsoft Corporation is developing extensions to the.NET framework to facilitate easier processing of non-objectoriented data models. Part of this project (known as “LINQ”) includes various extensions to the.NET languages to leverage this support. In this paper we consider proposals for C ♯ 3.0, the next version of the C ♯ programming language. We give both an informal introduction to the new language features, and a precise formal account by defining a translation from C ♯ 3.0 to C ♯ 2.0. This translation also demonstrates how these language extensions do not require any changes to the underlying CLR.
Typed Parametric Polymorphism for Aspects
, 2006
"... We study the incorporation of generic types in aspect languages. Since advice acts like method update, such a study has to accommodate the subtleties of the interaction of classes, polymorphism and aspects. Indeed, simple examples demonstrate that current aspect compiling techniques do not avoid run ..."
Abstract
-
Cited by 16 (0 self)
- Add to MetaCart
We study the incorporation of generic types in aspect languages. Since advice acts like method update, such a study has to accommodate the subtleties of the interaction of classes, polymorphism and aspects. Indeed, simple examples demonstrate that current aspect compiling techniques do not avoid runtime type errors. We explore type systems with polymorphism for two models of parametric polymorphism: the type erasure semantics of Generic Java, and the type carrying semantics of designs such as generic C#. Our main contribution is the design and exploration of a source-level type system for a parametric OO language with aspects. We prove progress and preservation properties. We believe our work is the first source-level typing scheme for an aspect-based extension of a parametric object-oriented language. Key words: Aspect-oriented programming, Typing, Generic types. 1
cJ: Enhancing Java with safe type conditions
, 2006
"... cJ is an extension of Java that allows supertypes, fields, and methods of a class or interface to be provided only under some static subtyping condition. For instance, a cJ generic class, C
, may provide a member method m only when the type provided for parameter P is a subtype of a specific typeQ ..."
Abstract
-
Cited by 12 (4 self)
- Add to MetaCart
cJ is an extension of Java that allows supertypes, fields, and methods of a class or interface to be provided only under some static subtyping condition. For instance, a cJ generic class, C<P>, may provide a member method m only when the type provided for parameter P is a subtype of a specific typeQ. From a practical standpoint, cJ adds to generic Java classes and interfaces the ability to express case-specific code. Unlike conditional compilation techniques (e.g., the C/C++ “#ifdef ” construct) cJ is statically type safe and maintains the modular typechecking properties of Java generic classes: a cJ generic class can be checked independently of the code that uses it. Just like regular Java, checking a cJ class implies that all uses are safe, under the contract for type parameters specified in the class’s signature. As a specific application, cJ addresses the well-known shortcomings of the Java Collections Framework (JCF). JCF data structures often throw run-time errors when an “optional ” method is called upon an object that does not support it. Within the constraints of standard Java, the authors of the JCF had to either sacrifice static type safety or suffer a combinatorial explosion of the number of types involved. cJ avoids both problems, maintaining both static safety and conciseness.
Javagi: Generalized interfaces for java
- In: ECOOP 2007, Proceedings. LNCS, Springer-Verlag (2007) 25
, 2007
"... Abstract JavaGI is an experimental language that extends Java 1.5 by generalizing the interface concept to incorporate the essential features of Haskell’s type classes. In particular, generalized interfaces cater for retroactive and constrained interface implementations, binary methods, static metho ..."
Abstract
-
Cited by 9 (1 self)
- Add to MetaCart
Abstract JavaGI is an experimental language that extends Java 1.5 by generalizing the interface concept to incorporate the essential features of Haskell’s type classes. In particular, generalized interfaces cater for retroactive and constrained interface implementations, binary methods, static methods in interfaces, default implementations for interface methods, interfaces over families of types, and existential quantification for interface-bounded types. As a result, many anticipatory uses of design patterns such as Adapter, Factory, and Visitor become obsolete; several extension and integration problems can be solved more easily. JavaGI’s interface capabilities interact with subtyping (and subclassing) in interesting ways that go beyond type classes. JavaGI can be translated to Java 1.5. Its formal type system is derived from Featherweight GJ. 1
State based encapsulation and generics
, 2004
"... A properly encapsulated data representation can be revised without affecting the correctness of client programs and extensions but encapsulation is difficult to achieve for heap based structures and object-oriented (OO) programs with reentrant callbacks. Building on a discipline that uses assertion ..."
Abstract
-
Cited by 6 (6 self)
- Add to MetaCart
A properly encapsulated data representation can be revised without affecting the correctness of client programs and extensions but encapsulation is difficult to achieve for heap based structures and object-oriented (OO) programs with reentrant callbacks. Building on a discipline that uses assertions and auxiliary fields to manage invariants and transferrable ownership, we give a rule for modular reasoning based on simulations. This representation independence result is proved for a sequential OO language with recursive, generic classes.
Formal Analysis of a Distributed Object-Oriented Language and Runtime
, 2004
"... Distributed language features form an important part of modern objectoriented programming. In spite of their prominence in today's computing environments, the formal semantics of distributed primitives for object-oriented languages have not been well-understood, in contrast to their sequential pa ..."
Abstract
-
Cited by 5 (5 self)
- Add to MetaCart
Distributed language features form an important part of modern objectoriented programming. In spite of their prominence in today's computing environments, the formal semantics of distributed primitives for object-oriented languages have not been well-understood, in contrast to their sequential part. This makes it difficult to perform rigorous analysis of their behaviour and develop formally founded safety methodologies. As a first step to rectify this situation, we present an operational semantics and typing system for a Java-like core language with primitives for distribution. The language captures the crucial but often hidden concerns involved in distributed objects, including object serialisation, dynamic class downloading and remote method invocation. We propose several invariant properties that describe important correctness conditions for distributed runtime behaviour. These invariants also play a fundamental role in establishing type safety, and help bound the design space for extensions to the language. The semantics of the language are constructed modularly, allowing straightforward extension, and this is exploited by adding primitives for direct code distribution to the language: thunk passing. Typing rules for the new primitives are developed using the invariants as an analysis tool, with type soundness ensuring that their inclusion does not violate safety guarantees.
Adding dynamic types to C ♯
"... Abstract. Developers using statically typed languages such as C ♯ and Java increasingly have to interoperate with APIs and object models defined in dynamic languages. This impedance mismatch results in code that is difficult to understand, awkward to analyze, and expensive to maintain. In this paper ..."
Abstract
-
Cited by 4 (0 self)
- Add to MetaCart
Abstract. Developers using statically typed languages such as C ♯ and Java increasingly have to interoperate with APIs and object models defined in dynamic languages. This impedance mismatch results in code that is difficult to understand, awkward to analyze, and expensive to maintain. In this paper we describe new features in C ♯ 4.0 that support the safe combination of dynamically and statically typed code by deferring type checking of program fragments with static type dynamic until runtime. When executed, these dynamic code fragments are typechecked and resolved using the same rules as statically typed code. We formalize these features in a core fragment of C ♯ and prove important safety properties. In particular, we show that subtyping remains transitive. 1
A Typed Logic for Stacks and Jumps: DRAFT
, 2004
"... This note shows how one may define a program logic in the style of Floyd and Hoare for a simple, typed, stack-based, imperative language with unstructured control flow and local variables. 1 ..."
Abstract
-
Cited by 1 (0 self)
- Add to MetaCart
This note shows how one may define a program logic in the style of Floyd and Hoare for a simple, typed, stack-based, imperative language with unstructured control flow and local variables. 1

