Jørgen Lindskov Knudsen

Advances in exception handling techniques

Language Support for Exception Handling.- Fault Tolerance and Exception Handling in BETA.- A Fully Object-Oriented Exception Handling System: Rationale and Smalltalk Implementation.- Condition Handling in the Lisp Language Family.- Design and Modeling of Exception Handling Structures.- Exception Safety: Concepts and Techniques.- Exceptions in Object Modeling: Finding Exceptions from the Elements of the Static Object Model.- Supporting Evolution of Interface Exceptions.- Exception Handling in Concurrent and Distributed Systems.- Concurrent Exception Handling.- Exception Handling in Agent-Oriented Systems.- Action-Oriented Exception Handling in Cooperative and Competitive Concurrent Object-Oriented Systems.- Exception Handling and Resolution for Transactional Object Groups.- Applications of Exception Handling Techniques.- Experiences with Error Handling in Critical Systems.- An Architectural-Based Reflective Approach to Incorporating Exception Handling into Dependable Software.- Adapting C++ Exception Handling to an Extended COM Exception Model.- Portable Implementation of Continuation Operators in Imperative Languages by Exception Handling.- Exception Handling in Information Systems.- Exception Handling in Object-Orienteda Databases.- Error Handling in Process Support Systems.- ADOME-WFMS: Towards Cooperative Handling of Workflow Exceptions.

Name Collision in Multiple Classification Hierarchies

Supporting multiple classification in object-oriented programming languages is the topic of discussion in this paper. Supporting multiple classification gives rise to one important question -- namely the question of inheritance of attributes with identical names from multiple paths in the classification hierarchy. The problem is to decide how these multiple classification paths are reflected in the class being denned. One of the conclusions in this paper is, that by choosing strict and simple inheritance rules, one is excluding some particular usages of multiple classification. This leads to the notion of attribute-resolution at class definition, which means that the programmer in some cases is forced or allowed to resolve the potential ambiguity of the inherited names. The concept of attribute-resolution is managed through the identification of two conceptually different utilizations of specialization (unification and intersection), and two different attribute properties (plural and singleton) to guide the attribute-resolution.

Better Exception-Handling in Block-Structured Systems

Few exception-handling language proposals support secure and well-behaved activity termination in block-structured systems. This proposed mechanism does.

Teaching Object-Oriented Programming Is More than Teaching Object-Oriented Programming Languages

One of the important obligations of an expanding research area is to discuss how to approach the teaching of the subject. Without this discussion, we may find that the word is not spread properly, and thus that the results are not properly utilized in industry. Furthermore, discussing teaching the research area gives additional insight into the research area and its underlying theoretical foundation. In this paper we will report on our approach to teaching programming languages as a whole and especially teaching object-oriented programming.The prime message to be told is that working from a theoretical foundation pays off. Without a theoretical foundation, the discussions are often centered around features of different languages. With a foundation, discussions may be conducted on solid ground. Furthermore, the students have significantly fewer difficulties in grasping the concrete programming languages when they have been presented with the theoretical foundation than without it.

A new virtual reality approach for planning of cardiac interventions

A novel approach to three-dimensional (3D) visualization of high quality, respiratory compensated cardiac magnetic resonance (MR) data is presented with the purpose of assisting the cardiovascular surgeon and the invasive cardiologist in the pre-operative planning. Developments included: (1) optimization of 3D, MR scan protocols; (2) dedicated segmentation software; (3) optimization of model generation algorithms; (4) interactive, virtual reality visualization. The approach is based on a tool for interactive, real-time visualization of 3D cardiac MR datasets in the form of 3D heart models displayed on virtual reality equipment. This allows the cardiac surgeon and the cardiologist to examine the model as if they were actually holding it in their hands. To secure relevant examination of all details related to cardiac morphology, the model can be re-scaled and the viewpoint can be set to any point inside the heart. Finally, the original, raw MR images can be examined on line as textures in cut-planes through the heart models.

Compiling java for low-end embedded systems

The production of embedded systems is continuously increasing, but developing reusable software for such systems is notoriously difficult, in particular in the case of low-end embedded systems based on 16-bit or 8-bit processors. We have developed a compilation system for executing Java byte code on low-end embedded systems, and we demonstrate how this system permits object-oriented programming techniques to be used on devices with only a few hundred bytes of RAM and a few kilobytes of ROM.We analyze the execution overheads of using object-orien\-ted programming on low-end embedded systems. Based on the conclusion that memory consumption is the major obstacle, we show how the configuration features and optimizations integrated into our compiler can be used to significantly reduce memory requirements. In particular, we use a novel approach based on Java interfaces to control integration of Java programs with the hardware, and demonstrate how aggressive whole-program optimization can significantly reduce the size of the compiled program.

Advanced Topics in Exception Handling Techniques

Programming Languages.- Bound Exceptions in Object-Oriented Programming.- Exception-Handling Bugs in Java and a Language Extension to Avoid Them.- Concurrency and Operating Systems.- Exception Handling in the Choices Operating System.- Handling Multiple Concurrent Exceptions in C++ Using Futures.- Exception Handling and Asynchronous Active Objects: Issues and Proposal.- Pervasive Computing Systems.- Exception Management Within Web Applications Implementing Business Processes.- Failure Handling in a Network-Transparent Distributed Programming Language.- Ambient-Oriented Exception Handling.- Exception Handling in CSCW Applications in Pervasive Computing Environments.- Structured Coordination Spaces for Fault Tolerant Mobile Agents.- Requirements and Specification.- Practical Exception Specifications.- Exception-Aware Requirements Elicitation with Use Cases.- An Approach to Defining Requirements for Exceptions.- Engineering and Experience.- Aspectizing Exception Handling: A Quantitative Study.- Errors and Exceptions - Rights and Obligations.- Exceptions in Java and Eiffel: Two Extremes in Exception Design and Application.

Exception handling—A static approach

This paper presents a static approach to exception handling. The static approach is proposed as a consequence of an examination of existing language constructs for exception handling in which several trouble spots have been revealed. The static approach consists basically of one concept, namely the sequel concept. Although the sequel concept is sufficient to specify exception handling within a program, one additional concept is introduced, namely the derived definition concept that is introduced as a generalization of the derived type and generic concepts from Ada.

Fault tolerance and exception handling in BETA

This paper describes the fault tolerance and exception handling mechanisms in the object-oriented programming language BETA. Exception handling in BETA is based on both a static and dynamic approach to exception handling in contrast to most other languages only supporting a dynamic approach. The BETA approach to static exception handling is based on a static termination model. Exceptions and their handlers may be defined both on the program, class, method, and instruction level, and default handlers for exceptions are defined as part of the definition of the ordinary handler. Exception propagation is under the control of the programmer. The BETA approach to dynamic exception handling is similar to other traditional dynamic exception handling models. Exception handlers are associated with blocks in the code, and in the case of an exception occurrence, the dynamic call-chain is scanned to find the dynamically nearest block with a handler matching the exception occurrence.

Generalising the BETA Type System

The type system of object-oriented programming languages should enable the description of models that originate from object-oriented analysis and design. In this paper, the BETA type system is generalised, resulting in direct language support for a number of new modelling aspects. The increased expressive power is obtained from a synergy between general block structure and the generalised type hierarchy, and not from syntactic additions to the language.