Ever since their invention 30 years ago, checked exceptions have been a point of much discussion. On the one hand, they increase the robustness of soft ware by preventing the manifestation of unanticipated checked exceptions at run-time. On the other hand, they decrease the adaptability of software bec ause they must be propagated explicitly, and must often be handled even if they cannot be signalled. We show that these problems are caused by a conflict between the exceptional interface of a method and the principle of abstraction. We then solve this conflict by introducing anchored exception declarations, which allow the exceptional behaviour of a method to be declared relative to that of others. We present their formal semantics, along with the necessary rules for ensuring compile-time safety, and give a proof of correctness. We show that ancho red exception declarations do not violate the principle of information hiding when used properly, and provide a guideline for when to use them. We have implemented anchored exception declarations as an extension to the ClassicJava programming language, called Cappuccino.

. Our goal is to support reuse and extensibility in distributed object systems. This requires some form of distributed inheritance and polymorphism. Most existing distributed system architectures can only cope with the inheritance and reuse of interface specifications. We discuss reuse requirements and approaches in general and their particularities in distributed systems. An approach is proposed that enables inheritance and reuse for object implementations. Our approach is based on a decoupling of object state and behavior. The behavior is implemented by so--called object engines. Our engine design and prototype implemementation are presented and compared to other well-known reuse techniques in distributed systems. 1 Introduction The enormous progress in computer and telecommunications technologies has led to distributed computing environments with a multitude of services, servers and clients. The terms service, server and client refer to the enterprise view of the acting entities in...

Abstract Model-Driven Development (MDD) is an emergent approach to software engineering which is based on the systematic use of software modeling as a primary form of expression. The central focus in MDD is on models, as opposed to source code in the traditional conception of software development. However the introduction of models in the software life cycle poses new issues and challenges that current state-of-the-art development tools do not support adequately. In this paper we investigate some of these challenges, taking into account the role played by models. Then we propose a unified framework which integrates different verification methods with the intent to check (UML) models against consistency issues and design defects. Our approach aims to integrate traditional techniques with model-based ones, keeping the advantages of both static and dynamic verification methods in order to increase the proficiency of the MDD activities. Model-Driven Development (MDD) is an emergent approach to software engineering which is based on the systematic use of software modeling as a primary form of expression. The central focus in MDD is on models, as opposed to source code in the traditional conception of software development. However the introduction of models in the software life cycle poses new issues and challenges that current state-of-the-art development tools do not support adequately. In this paper we discuss some of these challenges and how the practice of MDD affects software development tools. We start analyzing the role of models, that are a better medium than source code to express abstractions, which are the fundamental element of the software engineering practice [14,24]. Then we proceed addressing other issues concerned with models, the traditional activities of design, validation and verification (V&V). Taking into account these challenges allow us to identify the key features for developing a unified framework suitable to tailor the development process in the context of model-driven development environments, with particular attention to UML models.

This document provides an introduction to using Thor, an object oriented database, and its language Theta. This document applies to Thor Release 0.1. Topics include installation, writing Theta code to implement objects, writing C++ application code, and debugging.

Abstract: Following the dissolution of the Object Data Management Group (ODMG) in 2001, standardization efforts for object databases languished. What has emerged since is a fractured marketplace where each vendor has developed a unique set of programming interfaces and features and no truly portable way of interacting with an object database exists. In 2005, the OMG’s Object Database Technology Working Group was formed as the successor to the ODMG, and our first effort has been to create the object equivalent of the relational calculus. We believe that the foundation for this “object calculus ” can be found in the research done by Prof. Kazimierz Subieta and his students at the Polish-Japanese Institute of Information Technology. We have prepared this white paper to serve as an introduction to Prof. Subieta’s “stack-based architecture ” (SBA) and to define the OMG version of it. The definitions and semantics of SBA will, we believe, allow the construction of a complete and correct object model that supports a powerful object query language as well as a complete and correct set of equivalent native programming language bindings.

Abstract not found

The framework of promise theory offers an alternative way of understanding programming models, especially in distributed systems. We show that promise theory can express some familiar constructs and resolve some problems in program interface design, using fewer and simpler concepts than the Unified Modelling Language (UML). 1