Critical Evaluation of the EJB Transaction Model

Enterprise JavaBeans is a widely-used technology that aims at supporting distributed component-based applications written in Java. One of the key features of the Enterprise JavaBeans architecture is the support of declarative distributed transactions, without requiring explicit coding. In this paper, after a brief introduction of the concepts and mechanisms related to the EJB Transaction Model, we provide guidelines for their consistent use. We then evaluate the EJB Transaction Model on an Auction System case study. The encountered limitations are presented, and possible work-arounds are proposed for the auction system. We conclude with suggestions for enhancing the current EJB Transaction Model

From Use Cases to System Operation Specifications

The purpose of this paper is to first showcase the concept of an operation schema - a precise form of system-level operation specification and secondly show how operation schemas enhance development when they are used as a supplement to use case descriptions. An operation schema declaratively describes the effects of a system operation by pre- and postconditions using the Object Constraint Language (OCL), as defined by the Unified Modeling Language (UML). In particular, the paper highlights techniques to map use cases to operation schemas and discusses the advantages of doing so in terms of clarifying the granularity and purpose of use cases and facilitating a more systematic transition to design

A Side-by-Side Comparison of Exception Handling in Ada and Java

The purpose of this paper is to compare the exception handling mechanisms of Ada and Java. In order to be intelligible and useful to both communities, we have tried not get into specific technical intricacies of the languages, perhaps sometimes at the cost of precision. On the other side, we decided to use the language-specific terminology whenever we write about it. We believe that the contrary would often lead to misunderstandings: the same term sometimes covers two different concepts, e.g. object, or when the concepts are basically the same, the features provided by the language are largely different, making any unification impossible, e.g. task in Ada and thread Java

Enhancing OCL for Specifying Pre- and Postconditions

This paper proposes a number of enhancements to UML's Object Constraint Language to improve its usability for specifying operations by pre- and postconditions. In particular, we propose notational shortcuts and semantic modifications to OCL so that it can be more effectively used by developers. Also, the paper discusses an approach for specifying, in OCL, events and exceptions which are output and raised by an operation

Integrating CBSE, SoC, MDA, and AOP in a Software Development Method

Component-Based Software Engineering, Separation of Concerns, Model-Driven Architecture, and Aspect-Oriented Programming are four active research areas that have been around for several years now. In this paper, we present how these four paradigms can be put together in the context of a new software development method and we show how they can complement each other at different stages in the development life-cycle of enterprise, middleware-mediated applications. Different software development methods, such as Fondue, Catalysis, KobrA, and the Rational Unified Process, are also analyzed, pointing out their differences and limitations. In the end, requirements for a dedicated tool infrastructure that would support the new development approach are discussed

Better Generative Programming with Generic Aspects

Abstract. After a brief introduction to generative, generic, and aspect-oriented programming, we point out four key elements that appear in the definition of generative programming and that are addressed in this position paper from the perspective of distributed systems development. Then, based on a concrete RMI distribution example, we start motivating how the expressiveness power of generics and the crosscutting modularization power of aspects could be combined in order to achieve highly reusable generic aspects. We conclude by presenting how generic concern-oriented model transformations could help in providing the necessary information to aspect generators for automatically instantiating our generic aspects before weaving them into concrete applications

Generic Concern-Oriented Model Transformations Meet AOP

Abstract. Separation of concerns allows developers to manage large distributed systems by tackling one problem at a time. Model transformations refine models along one concern-dimension. Aspects encapsulate implementation details that cut across the boundaries of several components. In this position paper, after a short introduction to these emerging technologies, we explain how generic concern-oriented model transformations can meet aspect-oriented programming in order to complete the life-cycle of software application development in a pure MDA-compliant way based on separation of concerns. At the end, we present some requirements that tool vendors should provide if they decide to support such an approach

Specifying System Behavior in UML

The purpose of the paper is to present our approach for specifying system behavior. Our approach is based on operation schemas and a system interface protocol (SIP). Operation schemas describe the functionality of system operations by pre- and post-conditions; they are written in the Object Constraint Language (OCL), as defined by the Unified Modeling Language (UML). A SIP describes the temporal ordering of the system operations by a UML protocol statemachine. Operation schemas are hybrids of formal specifications approaches such as Z and VDM : hybrid in the sense that they are based on their formal counterparts but are targeted to developers that are more comfortable with procedural programming languages rather than declarative languages. Our approach offers a middle ground between the informal descriptions of use cases and the solution-oriented models of object interaction in UML. We believe that declarative behavioral specification techniques, like the one proposed in this paper, lead to more confidence in the quality of the software because they allow one to reason about system properties

Experience Report on the Implementation of Extenseible Protected Types for GNAT

Extensible Protected Types were devised to integrate concurrent and object-oriented features of Ada 95. This paper reports on a feasibility study based on implementing Extensible Protected Types for the GNAT compiler

Towards a UML Profile for Software Architecture

To formally describe architectures of software systems, specific languages called Architecture Description Languages (ADLs) have been developed by academic institutions and research labs. However, more and more research and industrial projects are using the standard Unified Modeling Language (UML) for representing software architectures of systems. In this paper, we focus on how to extend the UML by incorporating some key abstractions found in current ADLs, such as connectors, components and configurations, and how the UML can be used for modeling architectural viewpoints. Our approach is demonstrated by the software architecture of a video surveillance system. It is therefore the purpose of the paper to show that a UML profile for software architecture is needed