Concurrency within objects: layered approach

For some time, object-oriented programming has become standard practice in sequential programing. Objects separate the interface from the representation and promote reuse of code. Although concurrency is a natural consequence of objects, the standard model of objects uses sequential procedure calls. Early research in actors unifed concurrency with objects and provided a basis for use of objects in parallel and distributed systems.

Narrowing and heuristic search for symbolic reachability analysis of concurrent object-oriented systems

This study is to design a system of object-oriented model (OOM) reuse. This enhance the efficiency of software reuse through expressing object model utilizing cases, retrieving object model which is reused and developing object modeling procedure. We developed object model reuse system by case-based reasoning, called case-based object model reuse system (COMOR System). This system consists of four subsystems: the graphic user interface to interact with end-user, the object-oriented model management system to build a new object model, the case base to store the past object models, and the knowledge base to store object-oriented modeling and reusing knowledge.

In this paper, we investigate the formal specification of reactive systems described in an object-oriented style. We define a formalism, called ÉTOILE1-specifications, to deal with concurrent (active) object systems, and propose to extend algebraic approaches to dynamic and concurrent aspects by considering implicit states and implicit transitions, respectively. ÉTOILE-specifications emphasize systems composed of object types. Consequently, the ÉTOILE-formalism is split into two sub-formalisms. The first one enables us to specify the behaviour of object types. Then, it is extended from object types to systems by adding new requirements, mainly to describe the underlying architectural aspects of the system under specification (i.e. relationships between objects). The complexity of real systems results in the definition of formal means to manage their size. To deal with this issue, we propose a refinement of object type specifications by systems in the framework of ÉTOILE-specifications, which enables one to build his(her) specification in an incremental way.

60 Years of the Genocide Convention: An International Law Analysis

Creol is an object-oriented modeling language in which inherently concurrent objects exchange asynchronous method calls. The operational semantics of Creol is written in an actor-based style, formulated in rewriting logic. The operational semantics yields a language interpreter in the Maude system, which can be used to analyze models. Recently, Creol has been applied to the modeling of systems with radio communication, such as sensor systems. With radio communication, messages expire and, if sent simultaneously, they may collide in the air. In order to capture these and other properties of distributed systems, we extended Creol's operational semantics with a notion of time. We exploit the framework of a language interpreter to use a lightweight notion of time, in contrast to that needed for a general purpose specification language. This paper presents a timed extension of Creol, including the semantics and the implementation strategy, and discusses its properties using an extended example. The approach can be generalized to other concurrent object or actor-based systems.

Active object-oriented database systems (AOODBSs) are based on the object-oriented paradigm and provide an event driven behavior for implementing time critical reactions by integrating event-condition-action (ECA) rules to the database. We focus on the modeling aspects of AOODBSs. We propose an integrated approach, called A/OODBMT (Active Object-Oriented Database Modeling Technique), which integrates and extends the Object Modeling Technique (OMT) method for conceptually designing active object-oriented database applications. A/OODBMT models database applications by defining and integrating four new types of models, namely the nested object model (NOM), the behavior model (BM), the nested rule model (NRM), and the nested event model (NEM).

A comparison of the object model underpinning open systems interconnection (OSI) network management standards with that being developed for object-oriented software development systems indicates a close alignment between the models. But the OSI object-model goes further: it supports notions of asynchronously occurring events, concurrency, and optionality of implementation. These features are not found in the OMG object-model, but neither are they precluded. Consequently, the way is paved for network-management product suppliers to use OMG-conformant software-development systems. >

Virtual Reality (VR) provides immersive environments where users watch objects and scenes as if they were in front of users. This is a significant advantage while applying to 3D visualization systems. However, it is often difficult for novice users to make the best use of VR to reproduce the objects and scenes precisely and the comprehensively depending on the skills of users and the complexity of objects and scenes. One of the problems is that the allowed operations in VR are too flexible. Here, we propose a viewpoint selection method that allows every user to watch the objects and scenes easily and carefully in a VR space. The viewpoint is not fixed but can be shifted to the most favorable position according to the demand of users. Regarding the selected viewpoint as the initial position, users can easily go towards the target part with fewer movements. This system helps users to understand the complex objects in the VR space precisely with less time. We demonstrate our system on the observation of mode water pairs and discuss the comparative visualization results.

Reflection or metalevel architecture has received attention in recent years, since this approach provides functional extension and dynamic adaptation of computer systems. In this paper, we propose a technique to introduce reflection into a kind of algebraic system called rewriting logic. Since rewriting logic can model concurrent object-oriented systems, our technique enables modeling of reflective object-oriented systems including metaobjects and metaobject protocols. A framework for developing denotational semantics is given based on a category-theoretic model. We present some problems for finishing our semantics which remain unsolved.KeywordsInference RuleExecution ModelDenotational SemanticSemantic DomainAlgebraic SemanticThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The dissertation presents a new parallel programming paradigm for developing high performance (HPC) applications on the Grid. We address the question How to tailor HPC applications to the Grid? where the heterogeneity and the large scale of resources are the two main issues. We respond to the question at two different levels: the programming tool level and the parallelization concept level. At the programming tool level, the adaptation of applications to the Grid environment consists of two forms: either the application components should somehow decompose dynamically based on the available resources; or the components should be able to ask the infrastructure to select automatically the suitable resources by providing descriptive information about the resource requirements. These two forms of adaptation lead to the parallel object model on which resource requirements are integrated into shareable distributed objects under the form of object descriptions. We develop a tool called ParoC++ that implements the parallel object model. ParoC++ provides a comprehensive object-oriented infrastructure for developing and integrating HPC applications, for managing the Grid environment and for executing applications on the Grid. At the parallelization concept level, we investigate the parallelization scheme which provides the user a method to express the parallelism to satisfy the user specified time constraints for a class of problems with known (or well-estimated) complexities on the Grid. The parallelization scheme is constructed on the following two principal elements: the decomposition tree which represents the multi-level decomposition and the decomposition dependency graph which defines the partial order of execution within each decomposition. Through the scheme, the parallelism grain will be automatically chosen based on the available resources at run-time. The parallelization scheme framework has been implemented using the ParoC++. This framework provides a high level abstraction which hides all of the complexities of the Grid environment so that users can focus on the logic of their problems. The dissertation has been accompanied with a series of benchmarks and two real life applications from image analysis for real-time textile manufacturing and from snow simulation and avalanche warning. The results show the effectiveness of ParoC++ on developing high performance computing applications and in particular for solving the time constraint problems on the Grid.

Concurrent object-oriented programming systems require support for concurrency control, to enforce consistent commitment of changes and to support program-initiated rollback after application-specific failures. We have explored three different concurrency control models atomic blocks, serializable transactions, and commit-serializable transactions - as part of the MELD programming language. We present our designs, discuss certain programming problems and implementation issues, and compare our work on MELD to other concurrent object-based systems.

Parallel Computing on a network of workstations (NOW) is receiving a lot of attention from the research community. However, there is still a lack of tools for developing and running parallel applications on a NOW environment. In this paper, we develop and implement an object-oriented parallel programming system that facilitates the implementation of parallel applications on a NOW environment. In our programming system, a conceptual model, named Synchronous Object Model, is provided to help programmers write parallel programs. The object model makes use of the inherent parallel nature of an object-oriented model to express parallelism. In addition, an object-oriented framework is included into our programming system that reduces the size of parallel programs through code reuse and design reuse. Our system design further takes advantage of the underlying hardware architecture of the NOW environment to maximize performance by integrating multicast and load balancing support, and this is illustrated through experimental results.

User expertise and skill affects the way users interact with software. It is envisaged that an adaptive user interface (AUI) which dynamically changes from a novice user interface (UI) to an expert UI could possibly improve users' performance. Contact centres (CCs), are the primary interaction point between a company and its customers and an important challenge is to increase the speed at which contact centre agents (CCAs) retrieve information to answer customer queries. CCAs however have different capabilities, experience and expertise. Studies have provided empirical support that user performance can be increased when the computer UI characteristics match the user skill level. As a result, software systems have to become more individualised and cater for different users. This research focuses on applying this concept of AUIs to the domain of CCs and investigates whether an AUI for CCAs could improve the CCA's performance and enhance their interaction with UI. The main aim of this research study was to propose a model for AUIs which could be applied to the domain of CCs. The implementation of the proposed model was completed as proof of concept and the model was evaluated. The results indicate that the proposed AUI model significantly improves CCAs' performance and most users were satisfied with the adaptation provided by the model.

The basic features of object-oriented software makes it difficult to apply traditional testing methods in object-oriented systems. Control Flow Graph (CFG) is a well-known model used for identification of independent paths in procedural software. This paper highlights the problem of constructing CFG in object-oriented systems and proposes a new model named Extended Control Flow Graph (ECFG) for code based analysis of Object-Oriented (OO) software. ECFG is a layered CFG where nodes refer to methods rather than statements. A new metrics --Extended Cyclomatic Complexity (E-CC) is developed which is analogous to McCabe's Cyclomatic Complexity (CC) and refers to the number of independent execution paths within the OO software. The different ways in which CFG's of individual methods are connected in an ECFG are presented and formulas for E-CC for these different cases are proposed. Finally we have considered an example in Java and based on its ECFG, applied these cases to arrive at the E-CC of the total system as well as proposed a methodology for calculating the basis set, i.e., the set of independent paths for the OO system that will help in creation of test cases for code testing.