We present MultiJava, a backward-compatible extension to Java supporting open classes and symmetric multiple dispatch. Open classes allow one to add to the set of methods that an existing class supports without creating distinct subclasses or editing existing code. Unlike the “Visitor ” design pattern, open classes do not require advance planning, and open classes preserve the ability to add new subclasses modularly and safely. Multiple dispatch offers several well-known advantages over the single dispatching of conventional object-oriented languages, including a simple solution to some kinds of “binary method ” problems. MultiJava’s multiple dispatch retains Java’s existing class-based encapsulation properties. We adapt previous theoretical work to allow compilation units to be statically typechecked modularly and safely, ruling out any link-time or run-time type errors. We also present a novel compilation scheme that operates modularly and incurs performance overhead only where open classes or multiple dispatching are actually used. 1.

Two major obstacles hindering the wider acceptance of multi-methods are concerns over the lack of encapsulation and modularity and the absence of static typechecking in existing multi-method-based languages. This paper addresses both of these problems. We present a polynomial-time static typechecking algorithm that checks the conformance, completeness, and consistency of a group of method implementations with respect to declared message signatures. This algorithm improves on previous algorithms by handling separate type and inheritance hierarchies, abstract classes, and graph-based method lookup semantics. We also present a module system that enables independently-developed code to be fully encapsulated and statically typechecked on a per-module basis. To guarantee that potential conflicts between independently-developed modules have been resolved, a simple well-formedness condition on the modules comprising a program is checked at link-time. The typechecking algorithm and module system are applicable to a range of multi-method-based languages, but the paper uses the Cecil language as a concrete example of how they can be applied.

Metalevel tools can support the software development process by automating the design of task- and application-specific tools. Dash is a metalevel tool that allows developers to generate domain-specific knowledge-acquisition tools from domain ontologies. Domain specialists use the knowledge-acquisition tools generated by dash to instantiate the concepts and relationships defined in the domain ontologies. The output of the knowledge-acquisition tools is a collection of instances that constitute the knowledge base for a knowledge-based system.

ions are introduced using notation; conditionals are written using !; application is expressed by juxtaposition of the function being applied with its arguments. Recursion is expressed using letrec . 3.1 Records Records are non-strict finite associations of labels to values. The constituent expressions in a record are evaluated relative to the record's evaluation environment. The value of a record field can be retrieved using the "." operator: if r is a record, then evaluating r:x returns the binding value of x as defined in r. We provide one other operation over records. Let r 1 and r 2 be two records and let Dom(r) be the set of names defined within record r. The join or composition of r 1 and r 2 (written (ffl r 1 r 2 )) is now defined as follows: (ffl r 1 r 2 ):x = ae r 2 :x if x 2 Dom(r2) r 1 :x otherwise 3 Besides these basic syntactic forms, we introduce various syntactic extensions (or abbreviations) throughout the paper; these extensions are best thought of as macros th...

Abstract. ADDS (Approach to Document-based Development of Software) is an approach to the development of applications based on a document-oriented paradigm. According to this paradigm, applications are described by means of documents that are marked up using descriptive domain-specific markup languages. Afterwards, applications are produced processing these marked up documents. Formulation of domain-specific markup languages in ADDS is a dynamic and eminently pragmatic activity since these languages evolve in accordance with the authoring needs of the main actors that participate in the development process (i.e. domain experts and developers). OADDS (Operationalization in ADDS) is a processing model that promotes the construction of modular language processors and their incremental evolution. Thus, OADDS is specifically designed to cope with the evolutionary nature of the domain-specific markup languages encouraged by ADDS. ADDS and OADDS have successfully been applied to the development of applications in knowledge-intensive domains (i.e. transport networks and educational hypermedias). This paper also describes the advantages (incremental development and maintenance improvement) that this approach supposes for the development of knowledge-based systems. 1

Abstract not found

Abstract not found

We present and analyze the semantics and static type system for BeCecil, a theoretical (core) language with multimethods. BeCecil is a simple and orthogonal version of object-oriented languages like Cecil, CLOS, and Dylan. BeCecil has a new, simple mechanism for information hiding, which allows subclassing and yet can preserve representation invariants. BeCecil is also block-structured; within a block, one can extend a generic function with new multimethods, which may come from other generic functions. The inheritance relationships of objects may be extended in any block, and are statically scoped. The type system separates classes from types, and inheritance from subtyping. Subtype relationships are also extensible and statically scoped. These features combine to make BeCecil unusually expressive, while still allowing static typechecking.

Our project aims to automatically generating multilingual text for product maintenance, and documentation tasks from a structured knowledge representation. The substructure consists of both product specific as well as general technical domain knowledge. In particular, this is reusable knowledge about product functions, geometry and their composition, represented in a terminological knowledge representation system. The language independent representation is also designed to allow for the qualitative simulation of the documentation steps. This paper describes the implementation of some key modules, illustrated by a household toaster example. Our main implementation goals were reusability, extensibility and understandability of the representation. We discuss problems concerning the identification of relevant domain concepts, the realisation of part--whole relationships with the capability to propagate qualities (from parts to whole or vice versa), and the definition of electrical devices ...

Languages] Language Classifications — object-oriented languages; D.3.3 [Programming Languages] Language Constructs and Features — abstract data types, classes and objects, control structures, inheritance, modules, packages, patterns, procedures, functions, and subroutines; D.3.4 [Programming Languages] Processors — compilers; D.3.m [Programming Languages] Miscellaneous — multimethods, generic functions. Submitted for publication.