Narrow Results

To gain wider acceptance for the use of agents in industry, it is a necessity to relate it to the nearest antecedent technology (object-oriented software development) and to introduce appropriate artifacts to support the development environment throughout the full system life cycle. We address both of these requirements by presenting AGENT UML, the Agent UML (Unified Modeling Language) — a set of UML idioms and extensions. This paper provides an AGENT UML representation of the internal behavior of an agent; it then relates this internal description to the external behavior of the agent by using and extending UML class diagrams and by describing agent interaction protocols in a new way. Our claim is that by extending the de-facto standard representation for object-oriented modeling to agents, the learning curve for object-oriented developers to adopt aspects of agent-based programming becomes much less steep. Thus, agent-oriented programming as a whole will become more amenable to mainstream software engineering.

Software engineering relies on the possibility of describing a system at different levels of abstraction. Agent-oriented software engineering introduces a new level of abstraction, that we called agent level, to allow the architect modelling a system in terms of interacting agents. This level of abstraction is not supported by an accepted set of tools and notations yet, even if a number of proposals are available. This paper introduces: (i) An UML-based notation capable of modelling a system at the agent level and (ii) A development framework, called ParADE, exploiting such a notation. The notation we propose is formalized in terms of a UML profile and it supports the realisation of artefacts modelling two basic concepts of the agent level, i.e., the architecture of the multi-agent system and the ontology followed by agents. The choice of formalising our notation in terms of a UML profile allows using it with any off-the-shelf CASE tool. The ParADE framework takes advantage of this choice by providing a code generator capable of producing skeletons of FIPA-compliant agents from XMI files of agent-oriented models. The developer is requested to complete the generated skeletons exploiting the services that ParADE and the underlying agent platform provide.

As software is becoming larger and more complex, it is increasingly important to use the hierarchical modeling approach. Unfortunately, however, UML does not specify each metamodel with hierarchy for model by modeling phase. Thus, most UML-based methodologies do not address the hierarchical modeling for model. As a method for supporting hierarchical modeling on UML, this paper proposes a layered metamodel which defines hierarchically modeling elements of model according to the modeling phase. We describe each metamodel with hierarchy for models in UML, then present the hierarchical integrated metamodel combined with each metamodel by three modeling phases (conceptual phase, specific phase, and concrete phase). Therefore, designers are able to construct the hierarchical model by applying the metamodel with hierarchy. Using the hierarchical metamodel enables designers to improve the usability of UML and reusability of application model.

Design plays a key role in the development of software. The quality of design is crucial and is a fundamental decision element in assessing the software product. The early availability of design quality evaluation provides a better way to decide the quality of the final product. This avoids presumption in the quality evaluation process. Hence Software Metrics provide a valuable and objective insight of enhancing each of the software quality characteristics. This paper proposes a quality model to assess the design phase of any object-oriented system based on the works of Chidamber, Kemrer and Basili and suggests two new metrics. The research focuses on analyzing a set of metrics, which has direct influence on the quality of the software and creating a metrics tool based on Java that can be used to validate the object-oriented projects against these metrics. The analysis is carried out on a set of real world projects designed using Unified Modeling Language, which are used as test cases. These metrics and models are proposed to add more quality information in refining any object-oriented system during the early stages of design itself.

A method of functional testing for software components according to model-based testing techniques is proposed. Test cases are generated from UML diagrams and OCL constraints that comprise a component interface and realization specification. The method uses a reduced set of UML artifacts that constitute the main requirements for its application along with a component development process, making use of development artifacts. Also, the set of generated test artifacts are packed together with the provided components to reduce the overall testing effort when clients assemble applications. A tool has been developed to automate the method with test cases generated as Java test components. Test execution and result analysis is also supported. For each component, the tool generates a test component that can be easily upgraded and configured for testing the services provided by a component throughout its life cycle.

Application software development is normally the process of developing slightly different application models of the same application domain for different companies. Each application model corresponds to general features of the application domain and additionally involves supplementary requirements of a particular company. An application model for each individual company is always redesigned even though the general features can be reused. This leads to the need for new approaches to the development of a generic application model that can be reused with respect to a company's requirements. This paper presents a new development approach, namely Transformation-based Model Generation (TMG), which enhances the productivity of application development. It focuses on the reuse of a generic application model to automatically generate specific application models that satisfy different requirements of the same problem domain. The concepts of model representation and model generation are taken from Model Driven Architecture (MDA). XML Declarative Description (XDD) is the underlying theory for implementing the TMG. The knowledge for generating specific application models is domain-independent, hence it can be applied to various problem domains.

The Composition relationship or "black diamond" in the Unified Modeling Language (UML) is recognized for a long time as a key modeling construct. While prior research works demonstrated that this modeling operator had a dubious semantics, new expectations in the field of Component-Based Software Engineering especially, lead to revisit this operator so that it supports dynamical composition, and more precisely, composition modeling expressions and implementations that safely refer to states of software components. At first, the revision of the UML Composition must rely on well-formalized static dependencies between components as, for instance, the property of lifetime dependency between compound and constituent entities. This papers offers a UML metamodel and some associated logical assertions to strengthen the Composition relationship in UML 2. Despite the presence of new diagram types dedicated to composition (i.e., Composite Structure Diagrams), the UML 2 composition model is not yet sufficiently exhaustive and formal for dealing with all cases of composition, including those relating to agent, component or service computing and modeling.

This paper presents an approach to automated generation of executable test code from class models represented by the UML protocol state machines. It supports several coverage criteria for state models, including state coverage, transition coverage, and basic and extended round-trip coverage. It allows the tester to add and modify detailed test parameters (e.g., actual arguments for method invocations and implementation-specific environments) if necessary. When the state model is modified due to requirements change, the hand-crafted test parameters, if still valid, are automatically reused. This reduces the working load for regeneration of tests for modified models. In addition to test code, we also automatically generate state wrapper aspects in AspectJ, which facilitates comparing actual object states to expected states during test execution. This enables the automated verdict of pass/failure for test cases without the need to modify the source code of the class under test. We present two examples for which the executable test code is generated. They demonstrate the reuse of test parameters and testing of object interactions, respectively.

In this paper challenges of using Knowledge Engineering methods in the Software Engineering practice, with focus on the visual design methods for software applications, are discussed. The paper concerns practical design issues of rule-based models integrated with business applications built using the Model-View-Controller (MVC), or equivalent architectural pattern. The Unified Modeling Language (UML) constitutes a standardized notation among software engineers. Various attempts has been made to design the model in a way alternative to UML. Recently, the Business Rules approach has been proposed as a new way of capturing the functional requirements in a designer-friendly fashion. However, concepts on which the rule-based representation is based cannot be directly modeled in UML, because the semantics of UML diagrams does not correspond to rule semantics. Our research considers a method of designing rule bases which will be proper and consistent with the UML design. The approach has several important features: the core logic of the application is clearly identified and separated, and it is built in a declarative way, which makes the design transparent, easier to follow and develop. When rules are used to model the application logic, one has to keep in mind some common and well-known limitations of the existing rule tools. Our solution to these problems consists of using an expressive visual rule design formalism called XTT2, defining a direct translation between XTT2 and selected UML diagrams, implementing practical translators between the logical model and MOF-based UML model, and using the verification features provided with the XTT2 framework to assure the quality of the rule base. This solution seems to be superior both to existing visual UML rule notations, as well as visual design tools for rules. It does not extend any custom UML artifacts and can be used with standard UML tools.

UML is now popularly applied as a requirements modeling language for software system analysis and design, and the dynamic behaviors of system are described in UML behavioral model. As the UML model suffers from lack of well-defined formal semantics, it is difficult to formally analyze and verify the behavioral model. The paper presents a method of UML behavioral model verification based on Description Logic system and its formal inference. The semantics of UML behavioral models is divided into static semantics and dynamic semantics, which are formally specified in OWL DL ontology and DL-Safe rules. To check the consistency of the behavioral models, the algorithms are provided for transforming UML behavioral models into OWL DL ontology, and hence model consistency can be verified through formal reasoning with a DL supporting reasoner Pellet. A case study is provided to demonstrate applicability of the method.

The goal of the research was to check whether we can use a formal specification language such as OCL — Object Constraint Language to express all constraints on the library records proposed by the MARC 21 library standard. The main results are the classification and systematization of the constraints on the structure and the content of the MARC records as well as the specification of the constraints on the data model of MARC 21 in OCL. The obtained results are used in the implementation of the editor for MARC records for validation of the user input. The originality of the work is the adoption of the formal approach in specification of the constraints instead of writing source code in programming language.

Traceability between software requirements and UML design helps requirement engineers and software developers understand the project goal and software architecture. However, the traceability mapping between the two elements is not well-defined and as a result there is no consistent way to make the traceability between two. A practical guideline is proposed for the traceability between software requirement and UML design. The guideline includes meta-model and process step. The process step defines detailed processes and most importantly, the Requirement-type and its mapping to UML diagrams. Requirements can be categorized based on their aspects and this categorization can be made as Requirement-type. This pre-defined Requirement-type is added to each requirement and this Requirement-type enforces to use certain types of UML diagrams as solutions. This mapping between each Requirement-type and UML diagram is the key of proposed guideline. With the help of the Requirement-type and mapping, traceability link can be made easily and checked automatically. The guideline was applied to the Missile Project and Helicopter Project of ADD (Agency of Defense Development) in South Korea.

Nowadays, the Unified Modeling Language (UML) is the most successful notation for the design of object-oriented applications. However, plain UML is not enough to characterize the web presentation tier of enterprise applications, including the navigational, structural and role-based access control (RBAC) features present in these applications. In this paper, we present Enterprise Web Application Extension (E-WAE), a lightweight UML extension for the modeling of these elements, which permits the inclusion of multitier, Service-Oriented Architecture (SOA) and security design-level patterns in the models. Our approach follows a Model-Driven Development (MDD) approach, which enables the automatic generation of intermediate platform-specific models and automatic code generation for JavaServer Faces (JSF) and Active Server Pages.NET Model-View-Controller (ASP.NET MVC) frameworks. In addition, this generated code can be used as a low-cost mockup for early client validation of the navigational, structural and RBAC features of enterprise applications. E-WAE has been used with different applications. In this paper, we refer to the checkout process in the Amazon website, the delete resources use case in OdAJ2EE, an educational application developed by us, and the US Library of Congress Online Catalog search facility as examples of its applicability.

Consistency is a significant indicator to measure the correctness of a software system in its lifecycle. It is inevitable to introduce inconsistencies between different software artifacts in the software development process. In practice, developers perform consistency checking to detect inconsistencies, and apply their corresponding repairs to restore consistencies. Even if all inconsistencies can be repaired, how to preserve consistencies in the subsequent evolution should be considered. Consistency management (consistency checking and consistency preservation) is a challenging task, especially in the multi-view model-driven software development process. Although there are some efforts to discuss consistency management, most of them lack the support of formal methods. Our work aims to provide a framework for formal consistency management, which may be used in the practical software development process. A formal model, called a Structure model, is first presented for specifying the overall model-based structure of the software system. Next, the definition of consistency is given based on consistency rules. We then investigate consistency preservation under the following two situations. One is that if the initial system is inconsistent, then the consistency can be restored through repairs. The other is that if the initial system is consistent, then the consistency can be maintained through update propagation. To demonstrate the effectiveness of our approach, we finally present a case study with a prototype tool.

To manage the development of cooperative information systems that support the dynamics and mobility of modern businesses, separation of concern mechanisms and abstractions are needed. Model driven development (MDD) approaches utilize abstraction and transformation to handle complexity. In MDD, specifying transformations between models at various levels of abstraction can be a complex task. Specifying transformations for pervasive system services that are tangled with other system services is particularly difficult because the elements to be transformed are distributed across a model. This paper presents an aspect oriented model driven framework (AOMDF) that facilitates separation of pervasive services and supports their transformation across different levels of abstraction. The framework facilitates composition of pervasive services with enterprise services at various levels of abstraction. The framework is illustrated using an example in which a platform independent model of a banking service is transformed to a platform specific model.

Genetic programming (GP) is known to provide good solutions for many problems like the evolution of network protocols and distributed algorithms. In most cases it is a hardwired module of a design framework assisting the engineer in optimizing specific aspects in system development. In this article, we show how the utility of GP can be increased remarkably by isolating it as a component and integrating it into the model-driven software development process. Our GP framework produces XMI-encoded UML models that can easily be loaded into widely available modeling tools, which in turn offer code generation as well as additional analysis and test capabilities. We use the evolution of a distributed election algorithm as an example to illustrate how GP can be combined with model-driven development (MDD).

In recent years, how to apply immersive virtual reality technologies in education, psychological therapies and so on has increasingly been the object of study in recent years. In this study, we develop an interactive training application prototype of the full-color powder-based three-dimensional printing (3DP). The purpose of the application is to solve the problems encountered in the teaching, training and practicing 3DP in the university. These problems include the complicated operating processes, the discomfort of the respiratory tract caused by dust flying, the insufficient space not suitable for multi-person training, the high cost of consumables and so on. These limitations lead to the training stagnation and teaching inefficiency. To overcome these challenges, we develop the 3DP virtual laboratory by integrating immersive virtual reality technology and pedagogical content knowledge of 3DP. In brief, our main goal is to achieve the objective so that users can be familiar with the whole processes and know the usual troubleshooting techniques as they complete the different quests of the 3DP virtual laboratory before operating the real 3DP machine. Therefore, we implemented multimodal human-computer interactions for immersive virtual reality in the consideration of pedagogical content knowledge of 3DP. In addition, we can discuss the conceptual models of multimodal interactions in virtual reality development and users’ experiences from students’ feedback for the further development of the 3DP virtual laboratory.

This article summarizes the state of the art in software specification & design methods, which assist developers in constructing the models of the problem domain and of the system and in writing requirements and design specifications. The typical methods such as structured methods and object-oriented methods are summarized. The new discipline called “Method Engineering”, engineering for constructing methods, is briefly presented.

In the last years, an increasing number of computing systems are being realized by taking advantage of autonomous agents. Traditional software engineering methodologies are insufficient to be used in the development of such systems because of the particular characteristics of autonomous agents. Therefore, a lot of work has been done to extend traditional software engineering methodologies for agent systems and its result has been the definition of new methodologies of agent-oriented software engineering. This chapter introduces the basic concepts of agent-oriented software engineering showing the new artefacts that we introduced to analyze, design and implement multi-agent systems. In particular, we present a set of agent-oriented diagrams that support the modeling of: (i) the architecture of the multi-agent system, (ii) the ontology followed by agents and (iii) the interaction protocols used to coordinate agents. These artefacts are described, exploiting an UML-based notation that exploits stereotypes to provide agent-oriented semantics to class and collaboration diagrams.

Design patterns are considered one of the most valuable tools to produce quality designs and a general-purpose technique to improve a design is to identify all pattern realizations and to apply well-known rules to improve them. This technique requires finding all pattern realizations used in a design and it is a rather tedious task. This paper shows the work in the literature on assistants for programmers and software architects and presents a system called IDEA (Interactive DEsign Assistant). IDEA is an interactive design assistant for software architects meant for automating the task of finding and improving the realizations of design patterns. Basically, IDEA is capable of automatically (i) finding the patterns employed in a UML diagram and (ii) producing critiques about these patterns. The core of IDEA is the module that automatically detects the pattern realizations found in the model that the architect is producing. When this module finds a pattern realization, a set of design rules are verified to test if the design could be improved. Any violation to these rules fires a critique that is proposed to the engineer as a possible design improvement. Currently, a prototypal implementation of IDEA is integrated with two popular CASE tools.