Konstantin Läufer

Putting type annotations to work

We study an extension of the Hindley/Milner system with explicit type scheme annotations and type declarations. The system can express polymorphic function arguments, user-defined data types with abstract components, and structure types with polymorphic fields. More generally, all programs of the polymorphic lambda calculus can be encoded by a translation between typing derivations. We show that type reconstruction in this system can be reduced to the decidable problem of first-order unification under a mixed prefix.

Polymorphic type inference and abstract data types

Many statically typed programming languages provide an abstract data type construct, such as the module in Modula-2. However, in most of these languages, implementations of abstract data types are not first-class values. Thus, they cannot be assigned to variables, passed as function parameters, or returned as function results. Several higher-order functional languages feature strong and static type systems, parametric polymorphism, algebraic data types, and explicit type variables. Most of them rely on Hindley-Milner type inference instead of requiring explicit type declarations for identifiers. Although some of these languages support abstract data types, it appears that none of them directly provides light-weight abstract data types whose implementations are first-class values. We show how to add significant expressive power to statically typed functional languages with explicit type variables by incorporating first-class abstract types as an extension of algebraic data types. Furthermore, we extend record types to allow abstract components. The components of such abstract records are selected using the dot notation. Following Mitchell and Plotkin, we formalize abstract types in terms of existentially quantified types. We give a syntactically sound and complete type inference algorithm and prove that our type system is semantically sound with respect to standard denotational semantics.

Sisl: Several Interfaces, Single Logic

Modern interactive services such as information and e-commerce services are becoming increasingly more flexible in the types of user interfaces they support. These interfaces incorporate automatic speech recognition and natural language understanding and include graphical user interfaces on the desktop and web-based interfaces using applets and HTML forms. To what extent can the user interface software be decoupled from the service logic software (the code that defines the essential function of a service)? Decoupling of user interface from service logic directly impacts the flexibility of services, or how easy they are to modify and extend.To explore these issues, we have developed Sisl, an architecture and domain-specific language for designing and implementing interactive services with multiple user interfaces. A key principle underlying Sisl is that all user interfaces to a service share the same service logic. Sisl provides a clean separation between the service logic and the software for a variety of interfaces, including Java applets, HTML pages, speech-based natural language dialogue, and telephone-based voice access. Sisl uses an event-based model of services that allows service providers to support interchangeable user interfaces (or add new ones) to a single consistent source of service logic and data.As part of a collaboration between research and development, Sisl is being used to prototype a new generation of call processing services for a Lucent Technologies switching product.

Safe Structural Conformance for Java

In Java, an interface specifies public abstract methods and associated public constants. Conformance of a class to an interface is by name. We propose to allow structural conformance to interfaces: Any class or interface that declares or implements each method in a target interface conforms structurally to the interface, and any expression of the source class or interface type can be used where a value of the target interface type is expected. We argue that structural conformance results in a major gain in flexibility in situations that require retroactive abstraction over types. Structural conformance requires no additional syntax and only small modifications to the Java compiler and optionally, for performance reasons, the virtual machine, resulting in a minor performance penalty. Our extension is type-safe: A cast-free program that compiles without errors will not have any type errors at run time. Our extension is conservative: Existing Java programs still compile and run in the same manner as under the original language definition. Finally, structural conformance works well with recent extensions such as Java remote method invocation. We have implemented our extension of Java with structural interface conformance by modifying the Java Developers Kit 1.1.5 source release for Solaris and Windows 95/NT. We have also created a test suite for the extension. Konstantin Laufer* Gerald Baumgartner** Vincent F. Russo*** Safe Structural Conformance for Java Page 2 of 19

Type classes with existential types

We argue that the novel combination of type classes and existential types in a single language yields significant expressive power. We explore this combination in the context of higher-order functional languages with static typing, parametric polymorphism, algebraic data types and Hindley-Milner type inference. Adding existential types to an existing functional language that already features type classes requires only a minor syntactic extension. We first demonstrate how to provide existential quantification over type classes by extending the syntax of algebraic data type definitions, and give examples of possible uses. We then develop a type system and a type inference algorithm for the resulting language. Finally, we present a formal semantics by translation to an implicitly-typed second-order .̂-calculus and show that the type system is semantically sound. Our extension has been implemented in the Chalmers Haskell B. system, and all examples from this paper have been developed using this system. Capsule Review It is well known that existential quantifiers can be used to formalise the definition and use of abstract datatypes. However, few mainstream functional languages most of which are based on a polymorphic, Hindley-Milner type system provide any direct support for this. In previous work, both Perry and Laufer have studied extensions of the Hindley-Milner type system in which datatypes are used to manipulate values with existentially quantified types. The current paper extends their approach to a language that combines existential typing with the type class overloading mechanisms of Haskell. The main benefit is the ability to use type classes in the definition of abstract datatypes; classes themselves serve as datatype signatures, particular implementations can be coded up as instances of a class, and existential typing can be used to make these implementations abstract. The first part of the paper shows that the use of overloading can be quite convenient because it frees the programmer from the need to make explicit reference to the implementation of a particular datatype. On the other hand, this approach inherits some of the restrictions of the Haskell class mechanism. For example, it is not possible for different implementations to share a single representation type. The second part of the paper provides a formal treatment of the type system. In particular, it shows that well-typed terms have principal types and that the semantics of a program can be explained by a type-preserving translation into an implicitly typed, second-order X calculus. 486 Konstantin Laufer

A hike through post-EJB J2EE Web application architecture

Since the mid-nineties, server-based Web applications have emerged as a convenient way to provide functionality to a user audience without any specific software or system requirements except the need for a reasonably up-to-date Web browser. The tricky integration, installation, and configuration tasks are under the control of an expert on the server side. These advantages apply to both the general public and small research teams. Typical Web applications have browser-based user interfaces for one or more user roles and might keep some information in persistent storage, such as a relational database. Since the early days of common gateway interface (CGI) scripting, technologies for developing Web applications have evolved by leaps and bounds to address growing expectations with respect to reliability, maintainability, extensibility, performance, scalability, and other goals. In this article - the first in a planned series about Web application development - we take an exploratory hike through the architectural layers of a Web application built with state-of-the-art, widely used technologies. The paper focus on the upper layers that provide the applications user interface. By no means intended as a complete treatise on Web application development, this article is an overview meant to spark your interest and provide a starting Doint for further exploration.

Design and implementation of Triveni: a process-algebraic API for threads + events

We describe Triveni, a framework and API for integrating threads and events. The design of Triveni is based on an algebra, including preemption combinators, of processes. Triveni is compatible with existing threads standards, such as Pthreads and Java threads, and with the event models structured on the Observer pattern. We describe the software architecture and algorithms underlying a concrete implementation of Triveni in Java. This environment includes specification based testing of safety properties. The results described in the paper have been used to integrate process-algebraic methods into (concurrent) object orientated programming (C. Colby et al., 1998).

Plone and content management

This paper looks at Plone, one of the best content management systems. Plone is distributed under a free open-source license: the cost of getting started is only limited to the time you have available to set up the software on a server. Plone is written in Python and uses the Zope application server infrastructure; it runs on most modern operating systems. Plone can be customized for the maintenance of content - entirely over the Web.

Automated systematic testing for constraint-based interactive services

Constraint-based languages can express in a concise way the complex logic of a new generation of interactive services for applications such as banking or stock trading, that must support multiple types of interfaces for accessing the same data. These include automatic speech-recognition interfaces where inputs may be provided in any order by users of the service. We study in this paper how to systematically test event-driven applications developed using such languages. We show how such applications can be tested automatically, without the need for any manually-written test cases, and efficiently, by taking advantage of their capability of taking unordered sets of events as inputs.

What I Did on My Summer Vacation

This article discusses the continuing importance of requirements, managing Web content, free public Wi-Fi and a personal transition to Internet telephony.