While CORBA standard implementations and Object Databases (ODB) coexist on the market and are successfully used in different domains as autonomous tools, their integration is often called "synergy" because it offers great benefits for the both sides. The efficiency, flexibility and scalability of particular CORBA/ODB system depends on the properties of the mediating tier residing between two systems, through which the integration is done. Since the performance of CORBA/ODB system is heavily influenced by transactions overhead, the issue of transaction management has a crucial role in CORBA/ODB system's performance improvement. In this article some techniques aimed to minimizing the negative impact of transactions overhead on CORBA/ODB integrated system's performance are described and evaluated.

We propose a novel technique for recovering certain elements of the UML model of a software system. These include relationships between use cases as well as class roles in collaborations that realize each use case, identifying common functionality and thus establishing a hierarchical view of the model. The technique is based on dynamic analysis of the system for the selected test cases that cover relevant use cases. The theory of formal concept analysis is applied to obtain classification of model elements, obtained by the static analysis of code, in terms of use case realizations.

Since 1990 the Web has changed from a distributed hypertext system to an efficient environment for application delivery. Due to the legacy of the Web implementation model the development, management, and evolution of complex Web applications suffer from the coarse-grained model-entities. The demands can not be achieved without the application of programming technology and software engineering practice to applications in the Web, which is also referred to as Web Engineering. It has been recognized that the gap between design models and the implementation model of the Web leads to a development process that is hard to maintain, because fine-grained design entities get lost in the coarse-grained implementation model. Therefore, the coarse-grained implementation model hinders the maintenance and reuse of parts of an application. In this paper, the impacts on Web Engineering due to the coarse-grained Web implementation model are discussed and typical solutions that are related to the above problems are introduced. Then, the object-oriented WebComposition Markup Language will be presented as basis for a generic approach to component-based Web-application development.

The on-demand evaluation strategy (abbr. the on-demand E-strategy) is an extension of the evaluation strategy (abbr. the E-strategy) initiated by OBJ2. The strategy removes the restriction that the E-strategy imposes on constructing rewrite rules: if non-variable terms are put on lazy positions in the left sides, some terms cannot be rewritten as intended. We have written the operational semantics of rewriting with the on-demand E-strategy in CafeOBJ so that we can deeply understand rewriting with the on-demand E-strategy. The operational semantics can be used to observe the dynamic behavior of rewriting with the on-demand E-strategy thanks to the executability of CafeOBJ. A hint about the use of the on-demand E-strategy is given as well.

POOL is an object-oriented class-based language whose simple Pascal-like syntax, combined with static type-checking, facilitates the rapid construction of reliable reusable software components. Key features of the language include its subclass-as-subtype approach to inheritance, its view model, and its underlying strongly-typed persistent object store. POOL is designed to support the object-oriented paradigm without sacrificing the computational performance of traditional procedural languages, and has evolved through prototyping software solutions to problems drawn from a variety of application domains.

Client/Server models are the background for developing application programs in the field of electronic commerce. In this paper we present a web-based online consultant service for money investment. The developed Client/Server application is based on CORBA and Java. It enables customers to find the best investment strategies according to their personal preferences. In the article we give a survey of the tool and its implementation.

There are several different problem domains in the implementation of language processing tools. The manipulation of textual data when generating code, creation and inspection of environments during type checking, and analysis of dependency graphs during program optimization and parallelization are but a few. The use of domain specific languages to solve these sub problems can reduce the complexity of a tools specification. We argue this point in the realm of attribute grammars and use domain specific meta languages to write attribute definitions.

Some formalizations have been developed in order to give a complete description of the parallel semantics of P3L, a programming language which ensures both task and data parallelism. However, the description level provided by the employed formalisms is either too much `abstract' - unable to grasp the operational behavior of the skeletons of the language - or too much `concrete' - close to implementation details and therefore related to a particular machine model. This paper shows how the Gurevich's Abstract State Machines (ASMs) have been successfully employed to describe the parallel semantics of skeletons of P3L completely abstracting from any implementation detail. The proposed model describes both the operation of the compiler which leads to define a network of processes starting from a given program, and the computation of the running processes. The model has been also taken as a theoretical basis to prove some of the most interesting rewriting rules used by the compiler to get a better program performance and efficiency.

Many current programming languages offer insufficient support for the aggregation relationship. They do not offer a language support for composite structures (object hierarchies, whole/part hierarchies) on the object-level. Instead they rely on techniques, like embedding or referencing through pointers, which do not fully incorporate the semantics of aggregation. As a superior technique we present the language construct dynamic object aggregations.

We present the main features of Eclectic CSP -- an experimental language designed to support the specification and implementation of intelligent telecommunication network services, but applicable to any field requiring interprocess communication, a safe type system, and modular implementation.