Embedding Knowledge Elicitation and MT Systems within a Single Architecture

This paper describes Expedition, an environment designed to facilitate the quick ramp-up of MT systems from practically any alphabetic language (L) into English. The central component of Expedition is a knowledge-elicitation system that guides a linguistically naive bilingual speaker through the process of describing L in terms of its ecological, morphological, grammatical, lexical, and transfer information. Expedition also includes a module for converting the elicited information into the format expected by the underlying MT system and an MT engine that relies on both the elicited knowledge and resident knowledge about English. The Expedition environment is integrated using a configuration and control system. Expedition represents an innovative approach to answering the need for rapid-configuration MT by preparing an MT system in which the only missing link is information about L, which is elicited in a structured fashion such that it can be directly exploited by the system. In this paper we report on the current state of Expedition with an emphasis on the knowledge elicitation system.     

基于模型驱动架构的工作流管理系统开发研究

针对企业在导入或转换新的工作流平台时重新建模的问题,提出基于MDA的工作流管理系统开发架构.此架构中工作流程的建模分成两个阶段,首先设计了工作流程的PIM元模型并进行PIM建模,然后将PIM转换成PSM模型,最后再由PSM自动产生流程定义文件,这样在转移工作流程平台时,流程的PIM模型可以保留并以模型转换技术对应至新平台的PSM模型.给出了由PIM元模型转换为WfMC PSM模型的程序以及由WfMC PSM模型转换为XPDL流程定义的程序,并以电子订单工作流程为例进行了验证.此开发架构降低了流程平台转移时的成本与复杂度,提高了工作流程模型的可重用性.     

Linking Model-Driven Development and Software Architecture: A Case Study

A basic premise of Model Driven Development (MDD) is to capture all important design information in a set of formal or semi-formal models which are then automatically kept consistent by tools. The concept however is still relatively immature and there is little by way of empirically validated guidelines. In this paper we report on the use of MDD on a significant real-world project over several years. Our research found the MDD approach to be deficient in terms of modelling architectural design rules. Furthermore, the current body of literature does not offer a satisfactory solution as to how architectural design rules should be modelled. As a result developers have to rely on time-consuming and error-prone manual practices to keep a system consistent with its architecture. To realise the full benefits of MDD it is important to find ways of formalizing architectural design rules which then allow automatic enforcement of the architecture on the system model. Without this, architectural enforcement will remain a bottleneck in large MDD projects.     

Adaptive Agent Model: Software Adaptivity using an Agent-oriented Model-Driven Architecture

Model-Driven Architecture (MDA) promotes the development of software systems through successive building and generation of models, improving the reusability of models. Applying the same principles to the area of Agent-Oriented Software Engineering (AOSE) advances the ideas behind MDA even more significantly, due to the inherent adaptivity of software agents We describe an appropriate set of models originating from requirements specification and transformable to models understandable and executable by agents thus demonstrating an Agent-oriented Model-Driven Architecture (AMDA) approach. In AMDA, agents use hierarchical business knowledge models with business process rules at the top, business rules to control policy and logic in the middle and a base layer defining business concepts. Being externalised, knowledge is easily configurable by human beings and applied by software agents. A real case study is used to illustrate the process. The main advances over the object-oriented MDA are (i) the addition of component dynamics (ii) the use of agent-executable rule-based business models and (iii) a proposed higher level of abstraction with the direct representation of business requirements.     

Embedding finite automata within regular expressions

Regular expressions and their extensions have become a major component of industry-oriented specification languages such as IEEE PSL [IEEE Standard for Property Specification Language (PSL). IEEE Std 1850™-2005]. The model checking procedure of regular expression based formulas, involves constructing an automaton which runs in parallel with the model.     

A framework to identify primitives that represent usability within Model-Driven Development methods

ContextNowadays, there are sound methods and tools which implement the Model-Driven Development approach (MDD) satisfactorily. However, MDD approaches focus on representing and generating code that represents functionality, behaviour and persistence, putting the interaction, and more specifically the usability, in a second place. If we aim to include usability features in a system developed with a MDD tool, we need to extend manually the generated code.ObjectiveThis paper tackles how to include functional usability features (usability recommendations strongly related to system functionality) in MDD through conceptual primitives.MethodThe approach consists of studying usability guidelines to identify usability properties that can be represented in a conceptual model. Next, these new primitives are the input for a model compiler that generates the code according to the characteristics expressed in them. An empirical study with 66 subjects was conducted to study the effect of including functional usability features regarding end users’ satisfaction and time to complete tasks. Moreover, we have compared the workload of two MDD analysts including usability features by hand in the generated code versus including them through conceptual primitives according to our approach.ResultsResults of the empirical study shows that after including usability features, end users’ satisfaction improves while spent time does not change significantly. This justifies the use of usability features in the software development process. Results of the comparison show that the workload required to adapt the MDD method to support usability features through conceptual primitives is heavy. However, once MDD supports these features, MDD analysts working with primitives are more efficient than MDD analysts implementing these features manually.ConclusionThis approach brings us a step closer to conceptual models where models represent not only functionality, behaviour or persistence, but also usability features.     

OCL2Trigger: Deriving active mechanisms for relational databases using Model-Driven Architecture

Transforming integrity constraints into active rules or triggers for verifying database consistency produces a serious and complex problem related to real time behaviour that must be considered for any implementation. Our main contribution to this work is to provide a complete approach for deriving the active mechanisms for Relational Databases from the specification of the integrity constraints by using OCL. This approach is designed in accordance with the MDA approach which consists of transforming the specified OCL clauses into a class diagram into SQL:2003 standard triggers, then transforming the standard triggers into target DBMS triggers. We believe that developing triggers and plugging them into a given model is insufficient because the behaviour of such triggers is invisible to the developers, and therefore not controllable. For this reason, a DBMS trigger verification model is used in our approach, in order to ensure the termination of trigger execution. Our approach is implemented as an add-in tool in Rational Rose called OCL2Trigger.     

Model-Driven Development

The model-driven architecture (MDA) paradigm is well-known and widely used in the field of model-based software development. However, there are still some issues that are problematic and that need to be dealt with carefully. In this paper we present a metaphor that explains how MDA grows in complexity as problems faced become more difficult or “wicked”, and how a method designed to be powerful, flexible and MDA-compliant can eventually become, in effect, a “jigsaw puzzle”. This jigsaw puzzle is not merely the result of having a collection of methodological “pieces” with routes across them, but also arises as a result of the criteria underlying the MDA abstraction layers. We compare MDA to other research fields such as human-computer interaction, model management and method engineering, and we use as an example the OO-Method, a software development method based on MDA-compliant model transformations. We focus on a methodological piece that is conceived to allow the specification of interaction requirements by means of interface sketches. These sketches are supported by a task model that serves as a sound basis for formalisation and allows the application of model transformation in order to obtain subsequent models. A case study illustrates the requirements capture method together with the software development process defined by the OO-Method. The whole process presented in the case study represents one of the possible routes that can be followed when developing a software system with the OO-Method.     

Continuous Model-Driven Engineering

CMDE has been successfully applied in several industrial projects, including telecommunication services, supply-chain management, bioinformatics, logistics, and healthcare. In all these cases, agility at the customer, user, and application level proved key to aligning and linking business and IT. We now expect an additional boost when integrating this approach into a processor project-management environment that oversees development and evolution. This environment will include deadline management and progress reports, automatically informing all relevant parties when certain actions are required, managing different versions and product lines, and automatically steering the build and quality-management process. Perhaps not surprisingly, the development of this management environment proved to be a prime application of CMDE.     

Embedding Branch and Bound within Evolutionary Algorithms

A framework for hybridizing evolutionary algorithms with the branch-and-bound algorithm (B&B) is presented in this paper. This framework is based on using B&B as an operator embedded in the evolutionary algorithm. The resulting hybrid operator will intelligently explore the dynastic potential (possible children) of the solutions being recombined, providing the best combination of formae (generalized schemata) that can be constructed without introducing implicit mutation. As a basis for studying this operator, the general functioning of transmitting recombination is considered. Two important concepts are introduced, compatibility sets, and granularity of the representation. These concepts are studied in the context of different kinds of representation: orthogonal, non-orthogonal separable, and non-separable.The results of an extensive experimental evaluation are reported. It is shown that this model can be useful when problem knowledge is available in the form of an optimistic evaluation function. Scalability issues are also considered. A control mechanism is proposed to alleviate the increasing computational cost of the algorithm for highly multidimensional problems.     

Multi-perspective requirements engineering within NATURE

This paper argues that existing definitions of viewpoints in software engineering are inadequate for requirements engineering (RE). The ESPRIT 6353 NATURE basic research action proposes an alternative definition which recognises that viewpoints are social artefacts within the RE process. It also proposes novel computational mechanisms for analysing different viewpoints as a basis for more informed negotiation between viewpoint owners. This paper reports important aspects of this research and outlines an agenda for future research in multiperspective RE.This work was conducted when the author was with the Institute of Computer Science, Foundation for Research of Technology-Hellas     

Towards Model-Driven Testing

The OMG's Model-Driven Architecture is a strategy towards interoperability across heterogeneous middleware platforms through the reuse of platform independent designs based on the distinction of, and transformation between, platform-independent and platform-specific models.A corresponding strategy for model-driven testing requires a similar structure to facilitate, besides the generation of test cases and oracles, the execution of tests on different target platforms.In this paper, we discuss different aspects of such a strategy in a specific instance: the development of web-based distributed applications. In particular, we will be concerned with the problem of reusing platform-independent test cases and test oracles and with the generation of oracles from executable models.     

Embedding a triangular graph within a given boundary

Given a 3-vertex-connected triangular planar graph and an embedding of its boundary vertices, can the interior vertices be embedded to form a valid triangulation? We describe an algorithm which decides this problem and produces such an embedding if it exists.     

Embedding intelligent decision making within complex dynamic environments

Decision-making is a complex and demanding process often constrained in a number of possibly conflicting dimensions including quality, responsiveness and cost. This paper considers in situ decision making whereby decisions are effected based upon inferences made from both locally sensed data and data aggregated from a sensor network. Such sensing devices that comprise a sensor network are often computationally challenged and present an additional constraint upon the reasoning process. This paper describes a hybrid reasoning approach to deliver in situ decision making which combines stream based computing with multi-agent system techniques. This approach is illustrated and exercised through an environmental demonstrator project entitled SmartBay which seeks to deliver in situ real time environmental monitoring.     

Applying Security within a Service-Oriented Architecture

ABSTRACT

To paraphrase Calvin Coolidge, the business of the Internet is business ^{1 1}Coolidge, C. (1925, January 17). The press under a free government. Given before the American Society of Newspaper Editors in Washington, DC, The quote is actually “After all, the chief business of the American people is business.” . The more business done on the Internet, the more need for regulation of that business. Many of the existing government and industry regulations deal with security measures, and for that reason it's more important than ever to secure your company's IT infrastructure, no matter how large or small your company. Even if for some reason you're not subject to regulations, it's still a very good idea to secure your assets as if you were. At some point, your status might change, and besides, nobody wants to be hacked.     

Model-Driven Development in the Enterprise

For decades, model-driven development has been the perfect example of software-engineering hype. Just as bees are attracted to honey, we software engineers look for ways of simplifying our work and automating endless change cycles. Today, after many years of experimenting with MDD, mostly in limited-size scientific environments, the three ingredients of methodology, notation, and tools seem to fit and support each other. Round-trip engineering might still be some years from day-to-day practice, but simple forward engineering with MDD is readily available to software practitioners now. And it works. In this issue's column, Axel Uhl, chief development architect in SAP's Office of the CTO, looks into MDD methodologies and tool support. He shares his many practical experiences to help you master the ramp-up for your own enterprise.     

Towards a Subject-Oriented Model-Driven Framework

Model-Driven Architecture is an approach which tackles such problems as: the high availability that a software product requires to be ready for use, the high degree of evolution that a software system has nowadays, etc. However, in the development of large complex systems, the benefits of that approach have been diminished due to the size and complexity of models that describe these kinds of systems. At this point Aspect-Oriented Software Development (AOSD) appears to improve the understanding, reusability and adaptation of the software artefacts. Its mechanism is based on modularization of crosscutting concerns in well-identified isolated entities called aspects. For this reason we propose to use together AOSD and MDA in the hope of reducing the shortcomings of the latter. Thus, aspects like security, replication, real-time constraints, etc., will be modelled by specialist modellers independently throughout the MDA framework. Our proposal exploits a tool for checking the consistency between different models (aspects) at the same level of abstraction; supporting the traceability of UML elements, requirements, and concerns; and controlling the impact of changes throughout the MDA framework.     

Guest Editor's Introduction: Model-Driven Engineering

Model-driven engineering technologies offer a promising approach to address the inability of third-generation languages to alleviate the complexity of platforms and express domain concepts effectively.     

页面流模型驱动的Web应用框架研究

随着业务需求的日渐庞大,构筑大规模web应用系统变得愈加复杂。各种Web应用框架的出现,为应用开发人员提供了相当多的便利。然而目前大多数的Web应用框架仅为Web应用定义了一个层次清晰、分工明确的编程模型,实现这个模型仍然需要手工编写大量代码,而且基于XML的页面流配置文件往往冗长而难以维护。针对这些问题,论文提出了一种页面流模型驱动的Web应用开发框架,它以页面流模型的设计为核心,根据需求分析定制应用的整体业务流程,并给出了支持该框架的Web应用开发工具PFlowWeb。最后介绍一个由PFlowWeb开发的基于Web的文件共享交换系统的应用案例。实践表明,运用该平台可以有效提高大中型Web应用系统的开发效率,增强系统的健壮性和可扩展性。