An architecture for interpreted dynamic object-oriented languages

e code refers to the representation of bytecodes as constant C arrays that are located in sharable text segments after compilation. Interoperability, application start-up and dynamic memory usage benefit from this representation. Indexed code threading addresses the performance problem with virtual instruction mapping (i.e. loading, decoding and invoking) by using a fast threaded instruction transfer. Unlike with standard code threading, virtual machine code remains compact and executable also with a non-threaded virtual machine emulator. A further performance boost is achieved with optimal virtual instruction ordering. This technique helps to cluster the native code implementing virtual instructions so that native instruction cache performance is increased. Finally, the efficiency problem involved with dynamic method lookup is alleviated with an inline caching scheme that is applicable with constant bytecode vectors. The scheme exploits type locality similar to polymorphic inline cac

Entwurf und Implementierung effizienter Objektsysteme für funktionale und imperative Programmiersprachen am Beispiel von Lisp

Bisherige Objektsysteme funktionaler und imperativer Programmiersprachen weisen eine Lücke auf. Aus der funktionalen Tradition wurde das ausdrucksstärkste Objektsystem CLOS entwickelt, das insbesondere durch sein Metaobjektprotokoll hervorsticht, dessen Performanz aber zu wünschen übrig läßt. Auf der anderen Seite zeichnet sich C++ als besonders effizient aus, unterstützt aber zentrale Konzepte objektorientierter Programmierung wie Spezialisieren und Generalisieren von Objektklassen nur unzureichend, was abgeschwächt auch für Java gilt. In dieser Arbeit wird am Beispiel von Lisp gezeigt, wie man effiziente Objektsysteme unter Berücksichtigung des Verursacherprinzips so entwirft und implementiert, daß einfache Konstrukte keinen Overhead durch die Präsenz aufwendiger Konzepte, wie des Metaobjektprotokolls oder des Redefinierens von Klassen, mittragen müssen. Entgegen bisherigen Annahmen wird hier erstmals nachgewiesen, daß diese Konzepte auch ohne Quellcodeinterpretation bzw. -kompilation zur Laufzeit realisiert und somit auch in traditionellen, compiler-orientierten Programmiersprachen, wie Ada, Pascal, Eiffel, C++ und natürlich Java, unterstützt werden können.Up to now a gap is evident in object systems of functional and procedural programming languages. The most expressive object system developed in the family of functional languages is CLOS with its outstanding metaobject protocol. Its performance, however, does not meet the users' needs. In the family of procedural languages the most efficient object system developed is C++. But its support of central concepts of object-oriented programming, such as specialization and generalization of object classes, is not sufficient. This also applies in some degree for Java. Using Lisp as an example this thesis shows how efficient object systems can be designed and implemented so that simple constructs have no overhead because of the presence of complex concepts such as the metaobject protocol or the redefinition of classes. In contrast to former assumptions, this thesis proofs for the first time that the above mentioned concepts can be realized without embedding an interpreter or an incremental compiler in the run-time environment. Therefore, they can also be supported in traditional compileroriented programming languages such as Ada, Pascal, Eiffel, C++, and Java

GNU epsilon - an extensible programming language

Reductionism is a viable strategy for designing and implementing practical programming languages, leading to solutions which are easier to extend, experiment with and formally analyze. We formally specify and implement an extensible programming language, based on a minimalistic first-order imperative core language plus strong abstraction mechanisms, reflection and self-modification features. The language can be extended to very high levels: by using Lisp-style macros and code-to-code transforms which automatically rewrite high-level expressions into core forms, we define closures and first-class continuations on top of the core. Non-self-modifying programs can be analyzed and formally reasoned upon, thanks to the language simple semantics. We formally develop a static analysis and prove a soundness property with respect to the dynamic semantics. We develop a parallel garbage collector suitable to multi-core machines to permit efficient execution of parallel programs.Comment: 172 pages, PhD thesi

Reusable components for knowledge modelling

In this work I illustrate an approach to the development of a library of problem solving components for knowledge modelling. This approach is based on an epistemological modelling framework, the Task/Method/Domain/Application (TMDA) model, and on a principled methodology, which provide an integrated view of both library construction and application development by reuse. The starting point of the proposed approach is given by a task ontology. This formalizes a conceptual viewpoint over a class of problems, thus providing a task-specific framework, which can be used to drive the construction of a task model through a process of model-based knowledge acquisition. The definitions in the task ontology provide the initial elements of a task-specific library of problem solving components. In order to move from problem specification to problem solving, a generic, i.e. taskindependent, model of problem solving as search is introduced, and instantiated in terms of the concepts in the relevant task ontology, say T. The result is a task-specific, but method-independent, problem solving model. This generic problem solving model provides the foundation from which alternative problem solving methods for a class of tasks can be defined. Specifically, the generic problem solving model provides i) a highly generic method ontology, say M; ii) a set of generic building blocks (generic tasks), which can be used to construct task-specific problem solving methods; and iii) an initial problem solving method, which can be characterized as the most generic problem solving method, which subscribes to M and is applicable to T. More specific problem solving methods can then be (re-)constructed from the generic problem solving model through a process of method/ontology specialization and method-to-task application. The resulting library of reusable components enjoys a clear theoretical basis and provides robust support for reuse. In the thesis I illustrate the approach in the area of parametric design