14 research outputs found
Pragmatic Type Interoperability
Providing type interoperability consists in ensuring that, even if written by different programmers, possibly in different languages and running on different platforms, types that are supposed to represent the same software module are indeed treated as one single type. This form of interoperability is crucial in modern distributed programming. We present a pragmatic approach to deal with type interoperability in a dynamic and distributed environment. Our approach is based on an optimistic transport protocol, specific serialization mechanisms and a set of implicit type conformance rules. We experiment the approach over the .NET platform which we indirectly evaluate
Deconfined Intersection Types in Java
We show how Java intersection types can be freed from their confinement in type casts, in such a way that the proposed Java extension is safe and fully compatible with the current language. To this aim, we exploit two calculi which formalise the simple Java core and the extended language, respectively. Namely, the second calculus extends the first one by allowing an intersection type to be used anywhere in place of a nominal type. We define a translation algorithm, compiling programs of the extended language into programs of the former calculus. The key point is the interaction between ?-expressions and intersection types, that adds safe expressiveness while being the crucial matter in the translation. We prove that the translation preserves typing and semantics. Thus, typed programs in the proposed extension are translated to typed Java programs. Moreover, semantics of translated programs coincides with the one of the source programs
Java & Lambda: a Featherweight Story
We present FJ&, a new core calculus that extends Featherweight Java
(FJ) with interfaces, supporting multiple inheritance in a restricted form,
-expressions, and intersection types. Our main goal is to formalise
how lambdas and intersection types are grafted on Java 8, by studying their
properties in a formal setting. We show how intersection types play a
significant role in several cases, in particular in the typecast of a
-expression and in the typing of conditional expressions. We also
embody interface \emph{default methods} in FJ&, since they increase
the dynamism of -expressions, by allowing these methods to be called
on -expressions.
The crucial point in Java 8 and in our calculus is that -expressions
can have various types according to the context requirements (target types):
indeed, Java code does not compile when -expressions come without
target types. In particular, in the operational semantics we must record target
types by decorating -expressions, otherwise they would be lost in the
runtime expressions.
We prove the subject reduction property and progress for the resulting
calculus, and we give a type inference algorithm that returns the type of a
given program if it is well typed. The design of FJ& has been driven
by the aim of making it a subset of Java 8, while preserving the elegance and
compactness of FJ. Indeed, FJ& programs are typed and behave the same
as Java programs
Type-Safe Prototype-Based Component Evolution
Component-based programming is currently carried out using mainstream object-oriented languages. These languages have to be used in a highly disciplined way to guarantee flexible component composition and extensibility. This paper investigates abstractions for component-oriented programming on the programming language level. We propose a simple prototype-based model for first-class components on top of a class-based object-oriented language. The model is formalized as an extension of Featherweight Java. Our calculus includes a minimal set of primitives to dynamically build, extend, and compose software components, while supporting features like explicit context dependencies, late composition, unanticipated component extensibility, and strong encapsulation. We present a type system for our calculus that ensures type-safe component definition, composition, and evolution
Type-Based Publish/Subscribe
This paper presents type-based publish/subscribe, a new variant of the publish/subscribe paradigm. Producers publish message objects on a communication bus, and consumers subscribe to the bus by specifying the types of the objects they are interested in. Message objects are considered as first class citizens and are classified by their types, instead of arbitrarily fixed topics. By reusing the type scheme of the language to classify message objects, type-based publish/subscribe avoids any unnatural subscription scheme and provides for a seamless integration of a publish/subscribe middleware with the programming language. Type-based publish/subscribe has several quantifiable advantages over other publish/subscribe variants. In particular, the knowledge of the type of message objects enforces performance optimizations when combined with dynamic filters for content-based subscription. %from dynamically defined requirements. Our type-based publish/subscribe prototype is based on Distributed Asynchronous Collections (DACs), programming abstractions for publish/subscribe interaction. They are implemented using GJ, an extended Java compiler adding genericity to the Java language, and enable the expression of safely typed distributed interaction without requiring any generation of typed proxies
Pragmatic Type Interoperability
Providing type interoperability consists in ensuring that, even if written by different programmers, possibly in different languages and running on different platforms, types that are supposed to represent the same software module are indeed treated as one single type. This form of interoperability is crucial in modern distributed programming. We present a pragmatic approach to deal with type interoperability in a distributed system. Our approach is based on a specific serialization mechanism and a set of type conformance rules. We experiment the approach though .NET which we indirectly evaluate
Simplifying the use of event-based systems with context mediation and declarative descriptions
Current trends like the proliferation of sensors or the Internet of Things lead to Cyber-physical Systems
(CPSs). In these systems many different components communicate by exchanging events. While
events provide a convenient abstraction for handling the high load these systems generate, CPSs are very
complex and require expert computer scientists to handle correctly.
We realized that one of the primary reasons for this inherent complexity is that events do not carry
context. We analyzed the context of events and realized that there are two dimensions: context about
the data of an event and context about the event itself. Context about the data includes assumptions like
systems of measurement units or the structure of the encoded information that are required to correctly
understand the event. Context about the event itself is data that provides additional information to
the information carried by the event. For example an event might carry positional data, the additional
information could then be the room identifier belonging to this position.
Context about the data helps bridge the heterogeneity that CPSs possess. Event producers and consumers
may have different assumptions about the data and thus interpret events in different ways. To overcome
this gap, we developed the ACTrESS middleware. ACTrESS provides a model to encode interpretation
assumptions in an interpretation context. Clients can thus make their assumptions explicit and send them
to the middleware, which is then able to mediate between different contexts by transforming events.
Through analysis of the provided contexts, ACTrESS can generate transformers, which are dynamically
loaded into the system. It does not need to rely on costly operations like reflection. To prove this,
we conducted a performance study which shows that in a content-based publish/subscribe system, the
overhead introduced by ACTrESS’ transformations is too small to be measurable.
Because events do not carry contextual information, expert computer scientists are required to describe
situations that are made up of multiple events. The fact that CPSs promise to transform our everyday
life (e.g., smart homes) makes this problem even more severe in that most of the target users cannot
use CPSs. In this thesis, we developed a declarative language to easily describe situations and a desired
reaction. Furthermore, we provide a mechanism to translate this high-level description to executable
code. The key idea is that events are contextualized, i.e. our middleware enriches the event with the
missing contextual information based on the situation description. The enriched events are then correlated
and combined automatically, to ultimately be able to decide if the described situation is fulfilled or
not. By generating small computational units, we achieve good parallelization and are able to elegantly
scale up and down, which makes our approach particularly suitable for modern cloud architectures. We
conducted a usability analysis and performance study. The usability analysis shows that our approach
significantly simplifies the definition of reactive behavior in CPS. The performance study shows that the
achieved automatic distribution and parallelization incur a small performance cost compared to highly
optimized systems like Esper