MetaBETA: Model and Implementation

Object-oriented programming languages are excellent for expressing abstractions in many application domains. The object-oriented programming methodology allows real-world concepts to modelled in an easy and direct fashion and it supports refinement of concepts. However, many object-oriented languages and their implementations fall short in two areas: dynamic extensibility and reflection.Dynamic extensibility is the ability to incorporate new classes into an application at runtime. Reflection makes it possible for a language to extend its own domain, e.g., to build type-orthogonal functionality. MetaBETA is an extension of the BETA language that supports dynamic extensibility and reflection. MetaBETA has a metalevel interface that provides access to the state of a running application and to the default implementation of language primities.This report presents the model behind MetaBETA. In particular, we discuss the execution model of a MetaBETA program and how type- orthogonal abstractions can be built. This includes precentation of dynamic slots, a mechanism that makes is possible ectend objects at runtime. The other main area covered in this report is the implementation of MetaBETA. The central component of the architecture is a runtime system, which is viewed as a virtual machine whose baselevel interface implements the functionality needed by the programming language

Layered, server-based support for Object-Oriented application development

Journal ArticleThis paper advocates the idea that the physical modularity (file structure) of application components supported by conventional OS environments can be elevated to the level of logical modularity, which in turn can directly support application development in an object-oriented manner. We demonstrate this idea through a system-wide server process that manages a separate logical layer of components. The server is designed to be a central operating system service responsible for mapping component instances into client address spaces. We show how this model solves some longstanding problems with the management and binding of application components in existing operating system environments. We illustrate with examples that this model's effectiveness derives from its support for the cornerstones of 0-0 programming: classes and their instances, encapsulation, and several forms of inheritance

Adaptive object management for distributed systems

This thesis describes an architecture supporting the management of pluggable software components and evaluates it against the requirement for an enterprise integration platform for the manufacturing and petrochemical industries. In a distributed environment, we need mechanisms to manage objects and their interactions. At the least, we must be able to create objects in different processes on different nodes; we must be able to link them together so that they can pass messages to each other across the network; and we must deliver their messages in a timely and reliable manner. Object based environments which support these services already exist, for example ANSAware(ANSA, 1989), DEC's Objectbroker(ACA,1992), Iona's Orbix(Orbix,1994)Yet such environments provide limited support for composing applications from pluggable components. Pluggability is the ability to install and configure a component into an environment dynamically when the component is used, without specifying static dependencies between components when they are produced. Pluggability is supported to a degree by dynamic binding. Components may be programmed to import references to other components and to explore their interfaces at runtime, without using static type dependencies. Yet thus overloads the component with the responsibility to explore bindings. What is still generally missing is an efficient general-purpose binding model for managing bindings between independently produced components. In addition, existing environments provide no clear strategy for dealing with fine grained objects. The overhead of runtime binding and remote messaging will severely reduce performance where there are a lot of objects with complex patterns of interaction. We need an adaptive approach to managing configurations of pluggable components according to the needs and constraints of the environment. Management is made difficult by embedding bindings in component implementations and by relying on strong typing as the only means of verifying and validating bindings. To solve these problems we have built a set of configuration tools on top of an existing distributed support environment. Specification tools facilitate the construction of independent pluggable components. Visual composition tools facilitate the configuration of components into applications and the verification of composite behaviours. A configuration model is constructed which maintains the environmental state. Adaptive management is made possible by changing the management policy according to this state. Such policy changes affect the location of objects, their bindings, and the choice of messaging system

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

Automatic composition of semantic web services : an approach with asynchronous teams and genetic operators

Orientadores: Eleri Cardozo, Juan Manuel Adán CoelloTese (doutorado) - Universidade Estadual de Campinas, Faculdade de Engenharia Elétrica e de ComputaçãoResumo: A automação da composição de serviços Web é, na visão do autor, um dos problemas mais importantes da área de serviços Web. Além de outras características, destaca-se que somente a composição automática é capaz de lidar com ambientes mutáveis onde os serviços são permanentemente inseridos, removidos e modificados. Os métodos existentes para realizar a composição automática de serviços apresentam várias limitações. Alguns tratam de um número muito restrito de fluxos de controles e outros não consideram a marcação semântica dos serviços. Em adição, em muitos casos não há avaliações quantitativas do desempenho dos métodos. Desta forma, o objetivo desta tese é propor um método para realizar a composição automática de serviços Web semânticos que considera os cinco tipos básico de fluxo de controle identificados pela Workflow Management Coalition, a saber: sequencial, separação paralela, sincronização, escolha-exclusiva e união simples; bem como para o fluxo de controle em laço, considerado um fluxo do tipo estrutural. As regras que descrevem a composição entre os serviços são híbridas, baseadas em semântica e em técnicas de recuperação de informação. Os serviços são descritos em OWL-S, uma ontologia descrita em OWL que permite descrever semanticamente os atributos IOPE (parâmetros de entrada, de saída, pré-requisitos e efeitos) de um serviço, mas somente os parâmetros de entrada e saída foram levados em consideração neste trabalho. Para validar a abordagem foi implementado um protótipo que utilizou times assíncronos (A-Teams) com agentes baseados em algoritmos genéticos para realizar a composição segundo os padrões de fluxo sequencial, paralelo e sincronização. A avaliação experimental do algoritmo de composição foi realizada utilizando uma coleção de serviços Web semânticos pública composta de mais de 1000 descrições de serviços. As avaliações de desempenho, em vários cenários típicos, medidas em relação ao tempo de resposta médio e à quantidade de vezes em que a função de avaliação (função fitness) é calculada são igualmente apresentadas. Para os casos mais simples de composição, o algoritmo conseguiu reduzir o tempo de resposta em relação a uma busca cega em aproximadamente 97%. Esta redução aumenta à medida que a complexidade da composição também aumentaAbstract: The automation of the composition of Web services is, in the view of the author, one of the most important problems in the area of Web services. Beyond other characteristics, only the automatic composition can deal with a changing environment where the services are permanently inserted, removed, and modified. Existing methods performing the automatic service composition have several limitations. Some deal with a very limited number of control flow patterns, while others do not consider the semantic markup of services. In addition, in many cases there is no quantitative evaluation of the method's performance. In such a way, the objective of this thesis is to propose a method to perform the automatic composition of semantic Web services considering the five basic types of control flow identified by the Workflow Management Coalition, namely: sequential, parallel split, synchronization, exclusive choice and simple merge; and for loop control flow, classified as a structural control flow pattern. The rules that describe the composition of the service are hybrid: based in semantics and in information retrieval techniques. Services are described in OWL-S, an ontology described in OWL that allows the semantically description of the IOPE attributes (input, output, prerequisite and effect) of a service, but only the input and output parameters were taken into consideration in this work. A prototype was implemented to validate the proposed rules. An asynchronous Team (A-Team) algorithm with genetic agents was used to carry out the composition according to the sequential, parallel and synchronization control flows. The experimental evaluation of the composition algorithm employed a public collection of semantic Web services composed of more than 1000 descriptions of services. An experimental performance evaluation showed that, for simple composition cases, the algorithm reduced the average response time in approximately 97%, when compared to blind search. This reduction increases as the composition complexity increasesDoutoradoEngenharia de ComputaçãoDoutor em Engenharia Elétric

Operating system fault tolerance support for real-time embedded applications

Tese de doutoramento em Electrónica Industrial (ramo de conhecimento em Informática Industrial)Fault tolerance is a means of achieving high dependability for critical and highavailability systems. Despite the efforts to prevent and remove faults during the development of these systems, the application of fault tolerance is usually required because the hardware may fail during system operation and software faults are very hard to eliminate completely. One of the difficulties in implementing fault tolerance techniques is the lack of support from operating systems and middleware. In most fault tolerant projects, the programmer has to develop a fault tolerance implementation for each application. This strong customization makes the fault-tolerant software costly and difficult to implement and maintain. In particular, for small-scale embedded systems, the introduction of fault tolerance techniques may also have impact on their restricted resources, such as processing power and memory size. The purpose of this research is to provide fault tolerance support for real-time applications in small-scale embedded systems. The main approach of this thesis is to develop and integrate a customizable and extendable fault tolerance framework into a real-time operating system, in order to fulfill the needs of a large range of dependable applications. Special attention is taken to allow the coexistence of fault tolerance with real-time constraints. The utilization of the proposed framework features several advantages over ad-hoc implementations, such as simplifying application-level programming and improving the system configurability and maintainability. In addition, this thesis also investigates the application of aspect-oriented techniques to the development of real-time embedded fault-tolerant software. Aspect- Oriented Programming (AOP) is employed to modularize all fault tolerant source code, following the principle of separation of concerns, and to integrate the proposed framework into the operating system. Two case studies are used to evaluate the proposed implementation in terms of performance and resource costs. The results show that the overheads related to the framework application are acceptable and the ones related to the AOP implementation are negligible.Tolerância a falhas é um meio de obter-se alta confiabilidade para sistemas críticos e de elevada disponibilidade. Apesar dos esforços para prevenir e remover falhas durante o desenvolvimento destes sistemas, a aplicação de tolerância a falhas é normalmente necessária, já que o hardware pode falhar durante a operação do sistema e falhas de software são muito difíceis de eliminar completamente. Uma das dificuldades na implementação de técnicas de tolerância a falhas é a falta de suporte por parte dos sistemas operativos e middleware. Na maioria dos projectos tolerantes a falhas, o programador deve desenvolver uma implementação de tolerância a falhas para cada aplicação. Esta elevada adaptação torna o software tolerante a falhas dispendioso e difícil de implementar e manter. Em particular, para sistemas embebidos de pequena escala, a introdução de técnicas de tolerância a falhas pode também ter impacto nos seus restritos recursos, tais como capacidade de processamento e tamanho da memória. O propósito desta tese é prover suporte à tolerância a falhas para aplicações de tempo real em sistemas embebidos de pequena escala. A principal abordagem utilizada nesta tese foi desenvolver e integrar uma framework tolerante a falhas, customizável e extensível, a um sistema operativo de tempo real, a fim de satisfazer às necessidades de uma larga gama de aplicações confiáveis. Especial atenção foi dada para permitir a coexistência de tolerância a falhas com restrições de tempo real. A utilização da framework proposta apresenta diversas vantagens sobre implementações ad-hoc, tais como simplificar a programação a nível da aplicação e melhorar a configurabilidade e a facilidade de manutenção do sistema. Além disto, esta tese também investiga a aplicação de técnicas orientadas a aspectos no desenvolvimento de software tolerante a falhas, embebido e de tempo real. A Programação Orientada a Aspectos (POA) é empregada para segregar em módulos isolados todo o código fonte tolerante a falhas, seguindo o princípio da separação de interesses, e para integrar a framework proposta com o sistema operativo. Dois casos de estudo são utilizados para avaliar a implementação proposta em termos de desempenho e utilização de recursos. Os resultados mostram que os acréscimos de recursos relativos à aplicação da framework são aceitáveis e os relativos à implementação POA são insignificantes

Le projet HOP!: vers un enseignement de la programmation pour tous

Parce que, dans une large mesure, la programmation fait intervenir de nombreuses compétences implicites, qui ne peuvent s'acquérir que par la pratique, l'enseignement de l'informatique nous paraît aujourd'hui encore insatisfaisant. Dans cet article, nous présentons le système HOP! (aka. Hands-On-Programming!), qui est un environnement de programmation interactif destiné à être utilisé pour enseigner la programmation au moyen d'exemples développés de façon incrémentale, en partant de projets simples pour aller petit à petit vers des réalisations plus compliquées. La philosophie et la conception du système HOP! s'appuient sur un certain nombre de développements récents dans les domaines des sciences du langage, de la psychologie, et de la pédagogie, ainsi que sur une analyse de l'activité de résolution de problèmes en informatique