ICSOFT 2012 Abstracts


Area 1 - Models

Full Papers
Paper Nr: 4
Title:

Fence - A Context-free Grammar Parser with Constraints for Model-driven Language Specification

Authors:

Luis Quesada, Fernando Berzal and Francisco J. Cortijo

Abstract: Traditional language processing tools constrain language designers to specific kinds of grammars. In contrast, model-based language specification decouples language design from language processing. As a consequence, model-based language specification tools need general parsers able to parse unrestricted context-free grammars. As languages specified following this approach may be ambiguous, parsers must deal with ambiguities. Model-based language specification also allows the definition of associativity, precedence, and custom constraints. Therefore parsers generated by model-driven language specification tools need to enforce constraints. In this paper, we propose Fence, an efficient bottom-up chart parser with lexical and syntactic ambiguity support that allows the specification of constraints and, therefore, enables the use of model-based language specification in practice.

Paper Nr: 11
Title:

A Multidomain and Multilingual Conceptual Data Model for Online Reviews Representation

Authors:

Marcirio Silveira Chaves and Winnie Picoto

Abstract: User-Generated Content (UGC) such as online reviews are freely available in the web. This kind of data has been used to support clients’ and managerial decision making in several industries, e.g. books, tourism or hospitality. However, the challenge is how to represent this information in a structured way in order to leverage on the information provided by the use of Web 2.0 applications. To deal with this challenge, models and metamodels have been used to support a set of concrete applications in several sub-domains into Computer Science and Information Systems body of knowledge (Karagiannis and Höfferer, 2006). This paper focuses on the model-driven engineering and introduces a new multidomain and multilingual conceptual data model to represent UGC. This model is based on a characterization of online reviews and aims to capture all the facets of these reviews. The characterization of the reviews’ sentences extends previous models (such as Martin and White, 2007; Ding et al., 2008; Liu, 2010). Applications build on the model proposed in this paper may allow in-depth analysis of the fine-grained and disperse knowledge existent in the UGC. Furthermore, as this model is domain-independent it can be used to represent multiple types of reviews.

Paper Nr: 13
Title:

AXIOM: A Model-driven Approach to Cross-platform Application Development

Authors:

Xiaoping Jia and Christopher Jones

Abstract: The development and maintenance of mobile applications for multiple platforms is expensive. One approach to reducing this cost is model-driven engineering (MDE). In this paper, we present AXIOM, a model-driven approach for developing cross-platform mobile applications. Our approach uses a domain specific language (DSL) for defining platform-independent models (PIM) of mobile applications. It also defines a multi-phase, customizable transformation process to convert platform-independent models into native applications for target mobile platforms. Our approach could significantly reduce the development cost and increase the product quality of mobile applications. A prototype tool has been developed to demonstrate the feasibility of the approach. The preliminary findings are promising and show significant gains in development productivity.

Paper Nr: 26
Title:

EMF Components - Filling the Gap between Models and UI

Authors:

Lorenzo Bettini

Abstract: The Eclipse Modeling Framework (EMF) provides code generation facilities for building tools and applications based on structured data models. Most of the Eclipse projects which somehow have to deal with modeling data are based on EMF since it simplifies the development of complex software applications with its modeling mechanisms. However, we argue that from the user interface point of view, the development of applications based on EMF could be made simpler, with more code reuse, and without having to deal with too many internal details. For this reason, in this paper, we propose Emf Components, a lightweight framework that allows easy and quick development of applications based on EMF and it can be configured to use all kinds of EMF persistence implementations (e.g., XMI, Teneo, CDO). It aims at providing a set of reusable components like trees, tables and detail forms that manage the model with the introspective EMF capabilities. The framework provides basic UI implementations which are customizable in a declarative way and with dependency injection mechanisms.

Paper Nr: 64
Title:

Formal Analysis of Sequence Diagram with Combined Fragments

Authors:

Hui Shen, Mark Robinson and Jianwei Niu

Abstract: The Combined Fragments of UML Sequence Diagram permit various types of control flow among messages (e.g., interleaving and branching) to express an aggregation of multiple traces encompassing complex and concurrent behaviors. However, Combined Fragments increase the difficulty of Sequence Diagram comprehension and analysis. To alleviate this problem, we introduce an approach to formally describe Sequence Diagrams with Combined Fragments in terms of the input language of the model checker NuSMV. This approach permits the verification of desired properties against Sequence Diagrams.

Paper Nr: 95
Title:

Hybriding CMMI and Requirement Engineering Maturity & Capability Models - Applying the LEGO Approach for Improving Estimates

Authors:

Luigi Buglione, Jean Carlo Rossa Hauck, Christiane Gresse von Wangenheim and Fergal Mc Caffery

Abstract: Estimation represents one of the most critical processes for any project and it is highly dependent on the quality of requirements elicitation and management. Therefore, the management of requirements should be prioritised in any process improvement program, because the less precise the requirements gathering, analysis and sizing, the greater the error in terms of time and cost estimation. Maturity and Capability Models (MCM) represent a good tool for assessing the status of a set of processes, but an inner limit of any model is its scope and approach for describing a certain issue. Thus, integrating two or more models with a common area of focus can offer more information and value for an organization, keeping the best components from each model. LEGO (Living EnGineering prOcess) is an approach projected for this purpose. This paper proposes a LEGO application hybridizing a ‘horizontal’ model (a MM containing processes going through the complete supply chain, from requirements right through to delivery, e.g. CMMI or ISO 12207/15504) with a few specific ‘vertical’ models (MMs with focus on a single perspective or process category, e.g. TMMi or TPI in the Test Management domain, P3M3 and OPM3 in the Project Management domain) for Requirement Engineering.

Paper Nr: 96
Title:

An Implementation Approach to Achieve Metamodel Independence in Domain Specific Model Manipulation Languages

Authors:

Jerónimo Irazábal, Gabriela Pérez, Claudia Pons and Roxana Giandini

Abstract: Model Driven Engineering proposes a software development process in which the key notions are models that allow engineers to precisely capture relevant aspects of a system from a given perspective and at an appropriate level of abstraction. Then, models are manipulated with the goal of enabling the automated development of a system from its corresponding models. Unlike general-purpose modeling languages, domain-specific modeling languages can simplify the development of complex software systems by providing domain-specific abstractions for modeling the system and its transformations in a precise but simple and concise way. In this work we elaborate on the notion of domain specific model manipulation language, that is to say a model manipulation language tailored to a specific domain. In contrast to well-known model manipulation languages, such as EOL or ATL, the language syntax and semantics are directly related to a specific domain and/or kind of manipulation, making manipulation easier to write and understand. We present an implementation approach achieving complete platform-independence. We illustrate the proposal through a practical example.

Paper Nr: 97
Title:

Service-oriented Design of Metamodel Components

Authors:

Henning Berg

Abstract: Integration of models is an important aspect of Model-Driven Engineering. Current approaches of model integration rely on model weaving and model transformations. In particular, weaving of metamodels allows extending a metamodel with additional concepts, and thereby supporting a larger problem space. Unfortunately, weaving of metamodels is not trivial and requires in-depth knowledge both of the problem domains of the constituent metamodels and the modelling environment. In addition, name conflicts have to be resolved in an intrusive manner. Another disadvantage of many model weaving approaches is that concepts describing different concerns are mixed together without the possibility for semantically tracing the origin of the concepts. In this paper, we propose a new approach for combining metamodels by defining these as reusable services at a conceptual level. We will show that this approach both addresses the issues that arise when models are woven, and illustrate how metamodel components simplify modelling.

Paper Nr: 100
Title:

A Declarative Fine-grained Role-based Access Control Model and Mechanism for the Web Application Domain

Authors:

Seyed Hossein Ghotbi and Bernd Fischer

Abstract: Access control policies such as role-based access control (RBAC) enforce desirable security properties, in particular for Web-based applications with many different users. A fine-grained RBAC model gives the developers of such systems more customization and administrative power to control access to fine-granular elements such as individual cells of a table. However, the definition and deployment of such policies is not straightforward, and in many Web applications, they are hand-coded in the database or scattered throughout the application’s implementation, without taking advantage of underlying central elements, such as the data model or object types. This paper presents FRBAC, a fine-grained RBAC model for the Web application domain. FRBAC achieves separation of concerns for enforcing access to a range of objects with mixed-granularity levels. Moreover, it provides a unique testing mechanism that gives a guarantee to the developer about the correctness, completeness, and sufficiency of the defined FRBAC model, both internally and in the context of its target application. We use code generation techniques to compile the specification of a FRBAC model down to the existing tiers of an existing domain-specific Web programming language, WebDSL. We show the benefits of FRBAC on the development of a departmental Web site.

Paper Nr: 110
Title:

Linear Software Models for Well-composed Systems

Authors:

Iaakov Exman

Abstract: Modularity is essential for automatic composition of real software systems from ready-made components. But given ready-made components do not necessarily correspond exactly to the units and functionality of designed software system architecture modules. One needs a neat composition procedure that guarantees the necessary and sufficient components to provide required units. Linear Software Models are rigorous theoretical standards subsuming modularity. The Linear-Reducible model is proposed as a model of well-composed software systems, above and beyond software variability. Indeed, case studies of representative systems recognized as well-composed, be they small, intermediate building blocks or large scale, are shown to be Linear-Reducible. The paper lays down theoretical foundations – upon exact linear independence and reducible matrix concepts – providing new precise meanings to familiar modularity ideas, such as the single responsibility theorem. The theory uses a Modularity Matrix – linking independent software structors to composable software functionals in a Linear Model.

Short Papers
Paper Nr: 5
Title:

Parallel Finite State Machines for Very Fast Distributable Regular Expression Matching

Authors:

Luis Quesada, Fernando Berzal and Francisco J. Cortijo

Abstract: Regular expressions provide a flexible means for matching strings and they are often used in data-intensive applications. They are formally equivalent to either deterministic finite automata (DFAs) or nondeterministic finite automata (NFAs). Both DFAs and NFAs are affected by two problems known as amnesia and acalculia, and DFAs are also affected by a problem known as insomnia. Existing techniques require an automata conversion and compaction step that prevents the use of existing automaton databases and hinders the maintenance of the resulting compact automata. In this paper, we propose Parallel Finite State Machines (PFSMs), which are able to run any DFA- or NFA-like state machines without a previous conversion or compaction step. PFSMs report, online, all the matches found within an input string and they solve the three aforementioned problems. Parallel Finite State Machines require quadratic time and linear memory and they are distributable. Parallel Finite State Machines make very fast distributed regular expression matching in data-intensive applications feasible.

Paper Nr: 7
Title:

Model-driven Test Engineering - A Practical Analysis in the AQUA-WS Project

Authors:

C. R. Cutilla, J. A. García-García, J. J. Gutiérrez, P. Domínguez-Mayo, M. J. Escalona, L. Rodríguez and F. J. Domínguez-Mayo

Abstract: The effective application of test phases has been one of the most relevant, critical and cost phases in the life cycle of software projects in the last years. During the test phase, the test team has to assure the quality of the system and the concordance with the initial requirements of the system. The model driven paradigm is offering suitable results in some areas and the test phase could be one of them. This paper presents how the application of this paradigm can help to improve this aspect in the functional test generation and it analyses the experience in a real project developed under this approach.

Paper Nr: 12
Title:

Project Estimation with NDT

Authors:

J. Armario, J. J. Gutierrez, M. Alba, J. A. García García, J. Vitorio and M. J. Escalona

Abstract: Software Project Estimation is one of the most critical and complex task for a Project manager. Several techniques, tools and mechanisms were proposed in the literature. However, these solutions are sometimes difficult and expensive to be applied and too frequently, the final estimation is made according to the manager experience. In this paper we present a preliminary approach based on the Use Case Points technique, which is adapted for the Model-Driven environment of NDT. This technique is automatically applied, thanks to the metamodels definition, and it is presented in a tool named NDT-Counter. Additionally, the paper presents an initial empirical evaluation of the results.

Paper Nr: 17
Title:

A Framework for Creating Domain-specific Process Modeling Languages

Authors:

Henning Heitkötter

Abstract: Using domain-specific modeling languages to capture business processes can greatly enhance quality and efficiency of process modeling, because language and models are more expressive, concise and easy to understand. The development of domain-specific languages (DSLs) with accompanying tools and transformations is, however, a complex, time-consuming, and costly task. An efficient and simple approach to creating process modeling languages (PMLs) for specific business domains by reusing common parts is needed, where each resulting language is still optimally adjusted to its domain. For each of these languages, the abstract and concrete syntax have to be defined as well as transformations to more general languages. This paper presents DSLs4BPM, a generic framework for PMLs, which employs DSL modularization concepts to allow the derivation of domain-specific PMLs. The framework provides elements common to process modeling and a basic transformation to the generic Business Process Model and Notation 2.0. DSLs are created by adding own types to the framework language and own rules to the transformation at predefined extension points. The approach has been implemented based on the Eclipse Modeling Framework.

Paper Nr: 18
Title:

A Light-weight Tool Integration Approach - From a Tool Integration Model to OSLC Integration Services

Authors:

Weiqing Zhang, Birger Møller-Pedersen and Matthias Biehl

Abstract: Existing tool integration approaches integrate various tools directly through tool proprietary APIs. This kind of integration lacks standardization and are different case by case. Integration based upon common tool metamodels also turns to be too complicated and hard to maintain. In this paper we provide an approach which integrates tools based on a combination of tool metamodels and an integration model. Tool element representatives (Artifacts) are defined to make integrations more standardized and flexible compared to direct tool APIs. The approach links the tool integration model to the various tool metamodels, and provides mechanism by which the common integration properties and the various tool metamodels are related. An industrial case study has been performed to validate the approach with both scenarios of traceability and exchange of data based upon common data definitions.

Paper Nr: 28
Title:

Valkyrie: A UML-based Model-driven Environment for Model-driven Software Engineering

Authors:

Thomas Buchmann

Abstract: Model-driven software engineering aims at increasing productivity by replacing conventional programming with the development of high-level models. Over the years, UML has been established as a standard modeling language which is supported by a large number of tools. Unfortunately, many of these tools primarily focus on graphical editing of diagrams and lack sophisticated support for code generation. The Valkyrie environment addresses this shortcoming. While Valkyrie supports requirements elicitation with use case and activity diagrams, its main emphasis lies on analysis and design, which are based on package diagrams, class diagrams, statecharts, and the textual UML Action Language (UAL). Modeling-in-the-large is supported by package diagrams. Packages are refined into class diagrams. For some class, a statechart may be defined as a protocol state machine. Finally, a method of a class is defined by an activity diagram or a textual program written in UAL. From these artefacts, Valkyrie may generate fully executable code from a platform independent model. Valkyrie is built not only for, but also with model-driven software engineering. It is based on the Eclipse UML2 metamodel and makes use of several frameworks and generators to reduce implementation effort. This paper reports on the current state of Valkyrie, which is still under development.

Paper Nr: 45
Title:

Towards Modelling Real Time Constraints

Authors:

Amir Ashamalla, Ghassan Beydoun, Graham Low and Jun Yan

Abstract: Software agents are highly autonomous, situated and interactive software components. They autonomously sense their environment and respond accordingly. Agents behaviours are often constrained by by real time constraints such as the time in which the agent is expected to respond .i.e. time needed for a task to complete. Failing to meet such a constraint can result in a task being not achieved. This possibly causes an agent or a system to fail, depending on how critical the task is to the agent or system as a whole. Our research aims at identifying and modelling real time constraints in the early phase of analysis which helps in creating a more reliable and robust system.

Paper Nr: 48
Title:

On Measuring Smartphones’ Software Energy Requirements

Authors:

Hagen Höpfner, Maximilian Schirmer and Christian Bunse

Abstract: The continuous technological evolution of smartphones regarding their performance, networking facilities, and memory capacity, as well as various sensors, leads to a significant increase of a device’s energy requirements. Hence, energy demand is one of the most limiting factors of battery-driven, mobile devices. Improving energy demand by software optimisation often relies on simulated energy demand data. This paper evaluates two approaches for actually measuring real energy data with the goal to build an efficient and cost-effective basis for future research. The main question underlying this paper is: Is the preciseness of energy data provided by a smartphone’s operating system reliably close to the preciseness of data obtained via classic (i.e., hardware-based) measurement approaches. We defined a case study to evaluate this question. Our evaluation results show that software-based energy measures have an acceptable preciseness for comparative measures and are thus sufficient for research that warrants or requires total values.

Paper Nr: 50
Title:

Towards a Framework for Information System Testing - A Model-driven Testing Approach

Authors:

Federico Toledo Rodríguez, Beatriz Perez and Macario Polo Usaola

Abstract: Testing has an important role within the development of a software system; the automation of testing tasks has been largely used with the goal of minimizing costs and increasing productivity. For some of those tasks –as it is the execution of test cases– well-known solutions already exist as the industry adopted them many years ago. This is not the case with test data generation, and even less for software that uses databases, where this task is particularly complex. In the present work we propose to generate test cases automatically to test information systems that use relational databases. We represent the data model with UML Data Modeling Profile, automatically extracted from the database with reverse engineering techniques. Then, applying model-driven testing, test cases are generated from the data model, represented with the standard UML Testing Profile. The test case generation also includes test data inputs, in order to accomplish certain coverage criteria defined on the schema.

Paper Nr: 55
Title:

Tukra: An Abstract Program Slicing Tool

Authors:

Raju Halder and Agostino Cortesi

Abstract: We introduce Tukra, a tool that allows the practical evaluation of abstract program slicing algorithms. The tool exploits the notions of statement relevancy, semantic data dependences and conditional dependences. The combination of these three notions allows Tukra to refine traditional syntax-based program dependence graphs, generating more accurate slices. We provide the architecture of the tool, some snapshots describing how it works, and some preliminary experimental results giving evidence of the accuracy improvements it supports.

Paper Nr: 58
Title:

Automated Transformation of Use Case Maps to UML Activity Diagrams

Authors:

Yasser A. Khan and Mohamed El-Attar

Abstract: Use Case Maps (UCMs) is a modeling language that has been successfully deployed to model the behaviour of many types of systems, such as telecommunication systems, web applications, agent based systems and operating systems. However, as a high-level modeling language there exist a conceptual gap between UCMs and code-level. The crucial responsibility of filling this gap is usually undertaken by programmers, which leaves them prone to development mistakes and delivering an end system that does not accurately realize the behaviour specified in UCMs. UML activity diagrams (ADs) share many concepts with UCMs. Unlike UCMs however, many approaches have been proposed and implemented that transform ADs into other design artefacts. In particular, ADs can be transformed into class diagrams which can be used to generate code skeleton and ensure consistency between the programming and modeling efforts. To capitalize on the advantages of ADs, a model transformation approach from UCM notation to AD notation has been implemented and proposed in this paper. A case study is presented to illustrate the application of the proposed model transformation approach. The generated AD was thoroughly inspected and verified by the authors in addition to three independent Software Engineering professors at the host institution.

Paper Nr: 65
Title:

End-user Friendly UI Modelling Language for Creation and Supporting Evolution of RIA

Authors:

Chris D'Souza, Athula Ginige and Danny Liang

Abstract: End users have a comprehensive understanding of business needs which is often hard to fully capture. One possible solution to this is empowering end-users to create and manage business applications. To empower end-users the paper presents an end-user friendly UI modelling language. The language facilitates the creation and supports the evolution of RIAs with changing business needs. The modelling language is based on various types of structural dependencies among the interface elements in RIAs. These structural relationships are identified in the paper. It also derives the data model from the end-user UI specifications. Evolution is discussed from three perspectives, namely, the structural model of interfaces, the behavioural model of interfaces and the underlying data model.

Paper Nr: 71
Title:

Specification of Visual Instructional Design Languages Dedicated to Learning Management Systems

Authors:

Aymen Abedmouleh, Pierre Laforcade and Lahcen Oubahssi

Abstract: Despite of the growing development of learning technologies into education, designing learning scenarios and exploiting them for setting up a learning situation is still a complex task. Visual Instructional Design Languages (VIDL) and their dedicated graphical editors have been identified as important conceptual tools for achieving more creative design solutions within a design process. In this article we propose the application of Domain-Specific Modeling tools for specifying and developing VIDLs and editors dedicated to specific Learning Management Systems. An experimentation concerning the Moodle LMS is discussed.

Paper Nr: 80
Title:

Enterprise Ontology Driven Software Engineering

Authors:

Steven J. H. van Kervel, Jan L. G. Dietz, John Hintzen, Tycho van Meeuwen and Bob Zijlstra

Abstract: Model Driven Engineering (MDE) has been with us for quite some time, the most well known MDE approach being OMG’s Model Driven Architecture. Current MDE approaches suffer from two major shortcomings. First, they are unable to deliver domain models that comprise all functional requirements. Second, the models to be produced during the system development process, are not formally defined. One of the theoretical pillars of Enterprise Engineering (EE) is the Generic System Development Process (GSDP). It distinguishes between the using system and the object system, and it states that any software development process should start from the ontological construction model of the using system. In addition, EE’s systemic notion of Enterprise Ontology provides us with a formalized ontological model of an organization that satisfies the C4E quality criteria (Coherent, Consistent, Comprehensive, Concise, and Essential). An operational application software generator is presented that takes this ontological model, with some extensions, as source code input and executes the model as a professional software application. Changes in the software, as required by any agile enterprise, are brought about ‘on the fly’, through re-generation, based on the modified ontological model of the enterprise’s organization.

Paper Nr: 81
Title:

P²E: A Tool for the Evolution Management of UML Profiles

Authors:

Fadoi Lakhal, Hubert Dubois and Dominique Rieu

Abstract: UML profiles are a frequently used alternative to describe the abstract syntax of modelling languages. As any abstract syntax, UML profiles evolve through time. As the UML profiles are used by models, their evolutions may have a direct impact on them. In order to manage these evolutions, a specific treatment is needed. The models have then to be fitted to the new profiles version. The manual adaptation cost of these models may be as important as building the adapted models from scratch. In this paper, we deal with reducing the cost of models adaptation fitting the conducted evolution of the UML profiles. We provide an automatic treatment using a specific tool. The P²E tool has the ability to detect the changes occurred on the UML profiles, to classify them according to their impacts on the models and finally to adapt the models to the new version of the UML profile.

Paper Nr: 82
Title:

An Analysis Process for Identifying and Formalizing LMS Instructional Language

Authors:

Aymen Abedmouleh, Lahcen Oubahssi, Pierre Laforcade and Christophe Choquet

Abstract: Today, the LMS systems require some reengineering works or some additional design approaches because their uses have releaved many difficulties. The teachers-designers meet some obstacles when designing their learning scenarios. In this paper, we propose an LMS centered instructional design approach. This approach is based on the specific instructional language of the LMS system. It focuses on an original process for the identification and the formalization of the instructional language of LMS systems. This process takes into account two complementary viewpoints: the user-centered viewpoint based on the Human Machine Interfaces (HMI) analysis and the techno-centered viewpoint primarily based on the database analysis. We illustrate this process by an example of experimentation conducted on Moodle platform.

Paper Nr: 83
Title:

Traceability Support for MDE Development of Home Automation Systems

Authors:

Francisca Rosique, Pedro Sánchez, Diego Alonso and Manuel Jiménez

Abstract: Traceability is a technique to ease determining the impact of changes in the design of software, to support their integration, to preserve knowledge, and to assure the quality and accuracy of the overall system. In this paper, an approach that considers traceability in the context of model-driven development of Home Automation (HA) systems is presented. This combination enables the development of tools with techniques for improving the quality both of the process and of the models obtained. To obtain these advantages we have developed a tool that provides users with traceability reports after applying model transformations. These reports enable developers to study whether all requirements have been considered, the impact of changes, and how they are considered both in architectural decisions and code implementations.

Paper Nr: 88
Title:

Goal Based Alignment of Enterprise Architectures

Authors:

Balbir S. Barn and Tony Clark

Abstract: Business and IT alignment remains an ongoing concern for organizations. In this paper, we propose a set of technologies and concepts - notably goals and computable functions which can be used to provide a measure of equivalence between as-is and to-be enterprise architectures.

Paper Nr: 90
Title:

Medi SPICE and the Development of a Process Reference Model for Inclusion in IEC 62304

Authors:

Valentine Casey and Fergal Mc Caffery

Abstract: The demand for medical device software continues to grow and there is an associated increase in its importance and complexity. This paper discusses medical device software process assessment and improvement. It outlines Medi SPICE, a software process assessment and improvement model which is being developed to meet the specific safety-critical and regulatory requirements of the medical device domain. It also details the development of a subset of the Medi SPICE process reference model for inclusion in the next release of the IEC 62304 standard: Medical device software - Software life cycle processes. IEC 62304 is a key standard for medical device software development and is approved by many national regulatory bodies including the Food and Drug Administration in the United States and the European Union. This paper also outlines 3 lightweight software process assessment methods which have been developed in tandem with Medi SPICE. Finally the timeline for the release of the full Medi SPICE model is provided.

Paper Nr: 91
Title:

Evaluating Behavioral Correctness of a Set of UML Models

Authors:

Yoshiyuki Shinkawa

Abstract: In model driven software development, the correctness of models is one of the most important issues to construct high quality software in high productivity. Numerous research has been done to verify the correctness of those models. Conventional research mainly focuses on individual models, or at most the relationships between two individual models. However, the models must be correct as a whole set. This paper presents a Color Petri Net (CPN) based formal approach to verifying the behavioral correctness of UML models depicted by three different kinds of diagrams, namely state machine, activity, and sequence diagrams. This approach defines the correctness of a set of models from three different perspectives. The first perspective is the completeness that assures the syntactical correctness of the set. The second is the consistency that claims no conflicts between heterogeneous UML models. And the last is the soundness that represents the internal correctness of each model in the set.

Paper Nr: 109
Title:

Model-based Framework for Integrated Evolution of Business and IT Changes - Integrated Evolution of Business and IT Changes

Authors:

Anna Medve

Abstract: This paper introduces a goal-oriented framework which consists of generic and specific model repositories, and of methodology for integrated change management of business and IT evolutions. Is based on model compositions and traceability assessments of goal-oriented and scenario models. It contains a versioning-based cooperative work environment for business analysts to generate strategy decisions and simulations, themselves. The techniques and tools used are from the User Requirements Notation standard for requirements engineering and its supporting tools. Sets of models for visual documentation of BABOK 2.0 standard for business analysis, and of ISO/IEC 27001 and 27002 standards for information security, form the model repository to support developers and decision makers. These rise the generic aspect of the framework. An instantiation of framework for B2B change management with empirical validation within an SME, has been done. In a long way, this framework will be a base on a more complex system configuration control framework.

Paper Nr: 113
Title:

Composing Model Transformations at Runtime - An Approach for Adapting Component-based User Interfaces

Authors:

Diego Rodríguez-Gracia, Javier Criado, Luis Iribarne, Nicolás Padilla Soriano and Cristina Vicente-Chicote

Abstract: Nowadays, large part of the efforts in software development are focused on achieving systems with an as high as possible level of adaptation. With the traditional technique of model-driven development this can be largely accomplished. The inconvenience of these techniques however, is that the models are usually manipulated at design-time by means of fixed transformation. Furthermore, the transformations that manipulate these models cannot change dynamically according to the current execution context. This paper presents a transformation pattern aimed to adapt architectural models at runtime, this means that these models may change dynamically at runtime. The transformations that produce this model adaptation are not fixed, but dynamically composed by selecting the most appropriate set of rules from those available in a repository. As an example scenario for the application of these transformations, we chose architectural models representing component-based UIs.

Paper Nr: 116
Title:

CPN based Data Integrity Evaluation for Cloud Transactions

Authors:

Yoshiyuki Shinkawa

Abstract: Cloud computing environments, especially the PaaS environments, are one of the most promising platforms for high capacity and low cost transaction processing. However, today’s PaaS environments provide us with limited capability for data integrity in database and transaction processing, compared with traditional transaction management systems. Therefore, we need to evaluate whether the cloud environment currently considered provides enough capability for our data integrity requirements. This paper presents a Colored Petri Net (CPN) based approach to modeling and evaluating generalized transaction systems including cloud environments. The evaluation is performed based on the given constraints on database records expressed in the form of predicate logic formulae, and examined by CPN/ML codes implemented as the guard functions of the transitions for integrity verification.

Paper Nr: 118
Title:

EMF on Rails

Authors:

Rosa López-Landa, Julieta Noguez, Esther Guerra and Juan de Lara

Abstract: In this paper we propose leveraging existing frameworks for automated web application development, in the style of Ruby on Rails, Grails and Spring Roo, for their use within a Model-Driven Engineering process. Our approach automates the construction of domain-specific generators for web applications in particular domains. These generators are able to synthesize web applications using Spring Roo, starting from annotated models. In this way, designers of web applications do not need to be proficient in web automation frameworks, but they can benefit from the use of domain-specific, intuitive models. We illustrate our approach by generating an application to edit Eclipse Modelling Framework (EMF) models through the web.

Paper Nr: 122
Title:

Pattern-driven Reuse in Architecture-centric Evolution for Service Software

Authors:

Aakash Ahmad, Pooyan Jamshidi and Claus Pahl

Abstract: Service-based architectures implement business processes as technical software services to develop enterprise software. As a consequence of frequent business and technical change cycles, the architect requires a reuse-centered approach to systematically accommodate recurring changes in existing software. Our ‘Pat-Evol’ project aims at supporting pattern-driven reuse in architecture-centric evolution for service software. We propose architecture change mining as a complementary phase to a systematic architecture change execution. Therefore, we investigate the ‘history’ of sequential changes - exploiting change logs - to discover patterns of change that occur during evolution. To foster reuse, a pattern catalogue maintains an updated collection with once-off specification for identified pattern instances. This allows us to exploit change pattern as a generic, first class abstractions (that can be operationalised and parameterised) to support reuse in architecture-centric software evolution. The notion of ‘build-once, use-often’ empowers the role of an architect to model and execute generic and potentially reusable solution to recurring architecture evolution problems.

Paper Nr: 123
Title:

Unit Test - A Specialized Client in Refactoring

Authors:

Wafa Basit, Fakhar Lodhi and Muhammad Usman Bhatti

Abstract: Refactoring in several cases modifies the interface expected by the clients. These clients also include unit tests that make use of the refactored program entities and therefore get affected. But the key difference between an ordinary client and a unit test is the intent of use and a stronger association with the refactored class. A client makes use of the functionality offered by the system and completes its function. Whereas, a unit test verifies the functionality in terms of actual and expected outcomes. In the context of refactoring, a unit test is far more critical as it is the only safety net available to verify the impact of refactoring. Moreover, Unit tests are tightly coupled to the modules under test. In this paper we establish the fact that unit test is a different type of client that needs “special“ handling in refactoring. We demonstrate through most commonly used refactorings that there is a need to enhance the existing refactoring support for Java to include the specific adaptation mechanism for unit tests that eradicates the effect of refactoring and also improves the internal structure of test code.

Paper Nr: 124
Title:

A Metamodel for Functional Dependencies - Towards a Functional Dependency Model Transformation

Authors:

Manuel Enciso, Carlos Rossi and Antonio Guevara

Abstract: Model driven engineering has been shown to be a useful framework to enrich the quality of software. Metamodeling and model transformation have opened the door to specifying data models and manage it in a formal and solid way. These favourable features are particularly welcome in collaborative development, where we need a data model suitable for specifying information from different sources, and which can also facilitate the integration of this heterogeneous information to a global data model. In this paper we introduce a metamodel based on the notion of functional dependencies and we propose to use model driven engineering for the development of model transformation based on the SLFD logic.

Paper Nr: 125
Title:

Implementation of an A+ Interpreter for .NET

Authors:

Péter Gál and Ákos Kiss

Abstract: In this paper, we introduce a clean room implementation of an A+ interpreter for the .NET platform. Our goal was to allow interoperability between A+ and .NET programs, thus unlocking existing routines to .NET developers and making .NET class libraries available to A+ developers. In a preliminary experiment, we made the advantage of interoperability visible: we achieved a 5-fold speedup by calling .NET methods from an A+ script. Additionally, we have also shown how to use A+ as an embedded domain-specific language in C# code.

Paper Nr: 128
Title:

Automated Generation of User Interfaces - Based on Use Case or Interaction Design Specifications?

Authors:

Hermann Kaindl, Roman Popp and David Raneburger

Abstract: Instead of manually creating (graphical) user interfaces (UIs), automatically generating them is desirable, especially since UIs are needed today for diverse devices like PCs and smartphones. The basis for such automated generation can be a UI specification, but most of the related research takes task models as input, which are on a higher level of abstraction. More recently, another modeling language employing discourse-based models for specifying communicative interaction has been proposed, which completely abstracts from specifics of a particular UI and even its type. From such models, UIs can be generated automatically through model transformations. Some research, however, claims that UIs can be generated from use cases. While it would be desirable to utilize such a form of requirements definition without having to create another specification, we found that these approaches actually use additional information attached to the use cases, usually UI-related attachments. In addition to contrasting different kinds of specifications, we propose a synthesis through a combination. In fact, we found that discourse-based models can be also viewed as specifying classes of scenarios, i.e., use cases more precisely than the main-stream approach using UML and use-case reports.

Posters
Paper Nr: 9
Title:

Transforming SQLITE to Run on a Bare PC

Authors:

Uzo Okafor, Ramesh K. Karne, Alexander L. Wijesinha and Bharat S. Rawal

Abstract: SQLITE is a popular small open-source database management system with many versions that run on popular platforms. However, there is currently no version of the SQLITE application that runs on a bare PC. Since a bare PC does not provide any form of operating system (or kernel) support, bare PC applications need to be completely self-contained with their own interfaces to the hardware. Such applications are characterized by small code size, and have inherent security and performance advantages due to the absence of a conventional operating system. We describe a general transformation approach that can be used to transform the SQLITE application to a lean SQLITE application that runs on a bare PC. We present the current state of this work and identify several important issues that need further research.

Paper Nr: 16
Title:

A Framework for Developing Component-based Applications with Temporal Analysis Capabilities

Authors:

Francisco Sánchez-Ledesma, Juan Pastor, Diego Alonso and Francisca Rosique

Abstract: Reactive system design requires the integration of structural and behavioral requirements with temporal ones (along with V&V activities) to describe the application architecture. This paper describes an implementation framework for component-based applications that provides developers with great control over application concurrency (number of threads and their characteristics), the computational load assigned to them, and allows the temporal analysis of the applications developed with the framework. The paper presents an improved version of a framework previously developed, putting it in the context of a global Model-Driven Software Development approach for developing, analyzing and generating code for reactive applications.

Paper Nr: 27
Title:

Measuring UML Model Similarity

Authors:

Jie Su and Junpeng Bao

Abstract: Many user requirements and UML models are similar even if identical, but their application backgrounds are different. It is a straight and feasible way to mine those similar UML models for a model warehouse and reuse them so as to improve software development efficiency. The key point in the idea is to measure the similarity of UML models. We present a Level Edit Distance method to solve the problem. The LED measures similarity of XML structures instead of UML models. Indeed, UML models are converted to XML documents according to XMI so that UML model similarity equals to XML document similarity. However, our method concentrates on the pure structural similarity of UML models in XMI format, namely, the semantic information is ignored. The LED is different from the traditional Edit Distance. The former needs only one primitive operation whereas the later needs three. Our preparatory experimental results show that the LED can keep almost the same distance distribution with the traditional ED and is a little faster than the latter. We are going to improve the capability of the LED and combine it with a semantic-considered method in order to precisely evaluate the similarity of user requirements.

Paper Nr: 30
Title:

Model Driven Software Engineering for Grid Modeling, Optimization and Simulation

Authors:

Marcello Vitaletti, Nicola Fontana, Maurizio Giugni and Gianluca Sorgenti degli Uberti

Abstract: A three-year research project about water grid technology (“WATERGRID research project”) is led by ARIN – the company managing water distribution in the city of Naples – in a partnership with IBM and the University of Naples. Objectives of the project's initial phase include designing and prototyping a subsystem for grid modelling, optimization and simulation (GMOS). The GMOS subsystem implements state-of-the-art software kernels for the simulation of water distribution networks, including modules for the calibration of the hydraulic model and for an optimal partitioning of the grid. This paper illustrates general findings in applying model-driven software engineering to the architecture and design of the GMOS subsystem which largely abstract from the specific nature of the distribution grid as they could equally apply to the modelling, optimization and simulation of gas and electricity distribution networks.

Paper Nr: 34
Title:

Word Sense Disambiguation of Persian Homographs

Authors:

F. Jani and A.H. Pilevar

Abstract: This paper seeks to elaborate on the disambiguation of Persian words with the same written form but different senses using a combination of supervised and unsupervised method which is conducted by means of thesaurus and corpus. The present method is based on a previously proposed one with several differences. These differences include the use of texts which have been collected by supervised or unsupervised method. In addition, the words of the input corpus were stemmed, and in the case of those words whose different senses have different roles in the sentence, the role of the word in the input sentence was considered for disambiguation. Applying this method to the selected ambiguous words from “Hamshahri”, which is a standard Persian corpus, we achieved to a satisfactory accuracy of 97 percent in the results, and evaluated the presented method as a better and more efficient in comparison with the similar methods.

Paper Nr: 49
Title:

Modeling and Diagnosis Characterization using Timed Observation Theory

Authors:

I. Fakhfakh, M. Le Goc, L. Torres and C. Curt

Abstract: In this paper we propose using Timed Observation Theory as a powerful framework for model-based diagnosis. It provides a global formalism for modeling a dynamic tool (TOM4D) designed to characterize and compute diagnoses of a structure under investigation.

Paper Nr: 53
Title:

Modelling and Analysing Social Networks through Formal Methods and Heuristic Searches

Authors:

Antonella Santone and Gigliola Vaglini

Abstract: The paper presents a process algebraic approach to formal specification and verification of social networks. They are described using the Calculus of Communicating Systems and we reason and verify such formal systems by using directed model checking, which uses AI-inspired heuristic search strategies in order to improve model checking techniques.

Paper Nr: 56
Title:

Model Driven Development of Process-centric Web Applications

Authors:

Mario L. Bernardi, Marta Cimitile and Fabrizio M. Maggi

Abstract: Despite Model Driven Engineering (MDE) approaches are largely used to develop, update and evolve Web Applications (WAs), the use of these approaches for the development of process-centric WAs is still very limited. This is an important issue in the context of MDE considering thatWAs are often used to support users in the execution of business processes. In this paper, we propose the integration of three MDE metamodels used to represent the structure of information, service and presentation layers of a WA with the metamodel of Declare, a declarative language for business process rapresentation. The declarative nature of Declare allows us to combine an efficient roundtrip engineering support with the advantages of an MDE approach. We present and discuss a case study where the proposed approach is used to develop a typical online shopping application with the aim to validate and verify the feasibility and the effectiveness of the approach.

Paper Nr: 84
Title:

Unifying Event-based and Rule-based Styles to Develop Concurrent and Context-aware Reactive Applications - Toward a Convenient Support for Concurrent and Reactive Programming

Authors:

Truong-Giang Le, Olivier Hermant, Matthieu Manceny, Renaud Pawlak and Renaud Rioboo

Abstract: We propose a new programming language called INI, which combines both event-based and rule-based styles and is suitable for building concurrent and context-aware reactive applications. In our language, both events and rules can be defined intuitively and explicitly, in a stand-alone way or in combination. Events in INI can run in parallel in order to handle multiple tasks concurrently and may trigger actions defined in related rules. Besides, events can interact with the execution environment to adjust their behaviors if necessary and response to unpredicted changes. This makes INI a convenient language to write many kinds of programs which need to take advantages of concurrency and context-awareness, such as embedded software, interactive applications, sensors applications, robotic systems, etc.

Paper Nr: 99
Title:

A Model-driven Approach to Process Enactment

Authors:

Sana Damak Mallouli , Saïd Assar and Carine Souveyet

Abstract: Building software tools to support a new modeling formalism is a complex, error prone and time consuming task. Previous experiences have taught us that maintainability and portability are key issues which are poorly supported when development is realized in and ad-hoc manner. To overcome these limitations, we are investigating a meta-model driven approach for specifying at design phase not only the structural part of a process meta-model, but also its operational semantics in order to derive in a systematic manner an enactment engine. In this paper, we show how process model operational semantics are expressed by defining the architecture of an interactive enactment engine, and how the engine's behavior is formally specified using an event based notation. This approach includes an implementation step in which the engine behavior meta-model is transformed into a running system that is based on the publish/subscribe pattern.

Paper Nr: 112
Title:

Synthesis of Software from Logical Constraints

Authors:

Kevin Lano and Shekoufeh Kolahdouz-Rahimi

Abstract: This paper presents the case for constraints (requirements formalised as logical assertions) as the key starting point for software development. We describe how system development from such constraints can be automated.

Area 2 - Aspects

Full Papers
Paper Nr: 29
Title:

Generics and Reverse Generics for Pharo

Authors:

Alexandre Bergel and Lorenzo Bettini

Abstract: Generic programming is a mechanism for re-using code by abstracting specific types used in classes and programs. In this paper, we present a mechanism for adding generic programming in dynamically typed languages, showing how programmers can benefit from generic programming. Furthermore, we enhance the expressiveness of generic programming with reverse generics, a mechanism for automatically deriving new generic code starting from existing non-generic one. We implemented generics and reverse generics in Pharo Smalltalk, and we successfully used them to solve a problem of reusing unit test cases. This helped us to identify a number of bugs and anomalies in the stream class hierarchy.

Short Papers
Paper Nr: 85
Title:

Aspect-based On-the-Fly Testing Technique for Embedded Software

Authors:

Jong-Phil Kim, Jin-Soo Park and Jang-Eui Hong

Abstract: Various techniques for testing embedded software have been proposed as a result of the increased need for high quality embedded systems. However, it is hard to perform accurate testing with these techniques on failures that can occur unexpectedly in a real environment, because most of the tests are performed in software development environment. Therefore, it needs a testing technique that can dynamically test software’s latent faults in a real environment. In this paper, we propose an aspect-based On-the-Fly testing. The purpose of which is to test the functionalities and non-functionalities of embedded software using aspect-oriented programming at run-time in a real environment. Our proposed technique provides some advantages of prevention of software malfunction in a real environment and high reusability of test code.

Paper Nr: 92
Title:

Concept-Oriented Programming - Classes and Inheritance Revisited

Authors:

Alexandr Savinov

Abstract: The main goal of concept-oriented programming (COP) is describing how objects are represented and accessed. References (object locations) in COP are made first-class elements responsible for many important functions which are difficult to model via objects. COP rethinks and generalizes such primary notions of object-orientation as class and inheritance by introducing a novel construct, concept, and a new relation, inclusion. They make it possible to describe many mechanisms and patterns of thoughts currently belonging to different programming paradigms: modeling object hierarchies (prototype-based programming), precedence of parent methods over child methods (inner methods in Beta), modularizing cross-cutting concerns (aspect-oriented programming), value-orientation (functional programming).

Paper Nr: 94
Title:

Free Composition Instead of Language Dictatorship

Authors:

Lodewijk Bergmans, Steven te Brinke, Christoph Bockisch and Mehmet Akşit

Abstract: Historically, programming languages have been—benevolent—dictators: reducing all possible semantics to specific ones offered by a few built-in language constructs. Over the years, some programming languages have freed the programmers from the restrictions to use only built-in libraries, built-in data types, and builtin type-checking rules. Even though—arguably—such freedom could lead to anarchy, or people shooting themselves in the foot, the contrary tends to be the case: a language that does not allow for extensibility is depriving software engineers of the ability to construct proper abstractions and to structure software in the most optimal way. Therefore the software becomes less structured and maintainable than would be possible if the software engineer could express the behavior of the program with the most appropriate abstractions. The idea proposed by this paper is to move composition from built-in language constructs to programmable, first-class abstractions in a language. We discuss several prototypes of the Co-op language, which show that it is possible, with a relatively simple model, to express a wide range of compositions as first-class concepts.

Area 3 - Services

Full Papers
Paper Nr: 41
Title:

A Distributed Architecture for Remote Service Discovery in Pervasive Computing

Authors:

Farzad Salehi, Stefan D. Bruda, Yasir Malik and Bessam Abdulrazak

Abstract: Service discovery is very important in realizing the concept of pervasive computing. Consequently, service discovery protocols must be able to work in the heterogeneous environment offered by pervasive computing. Remote service discovery in particular has not been properly achieved so far. In an attempt to remedy this we propose a new architecture for enabling typical (local) service discovery mechanisms (without the ability of remote service discovery) to discover services remotely. Our architecture uses Universal Plug and Play (UPnP) as an example of local service discovery protocols, and Gnutella as an example of peer-to-peer distributed search protocols. We introduce a module called service mirror builder to the UPnP protocol, and a remote communication protocol over a Gnutella network. As a consequence, UPnP networks become able to discover services in remote networks (that is, remote service discovery).

Paper Nr: 87
Title:

Architecting a Large-scale Elastic Environment - Recontextualization and Adaptive Cloud Services for Scientific Computing

Authors:

Paul Marshall, Henry Tufo, Kate Keahey, David La Bissoniere and Matthew Woitaszek

Abstract: Infrastructure-as-a-service (IaaS) clouds, such as Amazon EC2, offer pay-for-use virtual resources on-demand. This allows users to outsource computation and storage when needed and create elastic computing environments that adapt to changing demand. However, existing services, such as cluster resource managers (e.g. Torque), do not include support for elastic environments. Furthermore, no recontextualization services exist to reconfigure these environments as they continually adapt to changes in demand. In this paper we present an architecture for a large-scale elastic cluster environment. We extend an open-source elastic IaaS manager, the Elastic Processing Unit (EPU), to support the Torque batch-queue scheduler. We also develop a lightweight REST-based recontextualization broker that periodically reconfigures the cluster as nodes join or leave the environment. Our solution adds nodes dynamically at runtime and supports MPI jobs across dis-tributed resources. For experimental evaluation, we deploy our solution using both NSF FutureGrid and Amazon EC2. We demonstrate the ability of our solution to create multi-cloud deployments and run batch-queued jobs, recontextualize 256 node clusters within one second of the recontextualization period, and scale to over 475 nodes in less than 15 minutes.

Short Papers
Paper Nr: 6
Title:

Support Cross-domain Components Composition in Software Production Lines

Authors:

Basem Y. Alkazemi

Abstract: Software product lines SPL are of obvious significance to the software development process as it mostly rely on identifying commonalities within an application domain to facilitate component integration for building new software product. The main focus of SPL is the development of software systems in single domain where some basic functionality are re-user all over the developed systems. However, when it comes to cross-domains component re-use, SPL development processes always encounter difficulties in integrating heterogeneous components where different architectural assumptions are need to incorporate them into a system. This paper establishes a significant distinction of component interfaces and utilizes it to derive the building of a SPL that can support developing cross-domains software re-use.

Paper Nr: 23
Title:

Metasearch Services Composition in WS-BPEL - An Application of Metamorphic Testing

Authors:

Carmen Castro, Inmaculada Medina-Bulo and Azahara Camacho

Abstract: Nowadays, the impact of Web Services is quickly increasing because of transactions through Internet. The OASIS WS-BPEL 2.0 standard language allows to develop business processes by means of pre-existing Web Services and to offer themselves as a new Web Service. This makes it necessary to pay special attention to testing this type of software and presents a challenge for traditional testing techniques, due to the inclusion of specific instructions for concurrency, fault and compensation handling, and dynamic service discovery and invocation. Metamorphic Testing has proved useful to test and improve the quality of traditional imperative programs. However, it has not been applied to languages for composingWeb Services such a WS-BPEL. This work presents an procedure for applying Metamorphic Testing to Web Services compositions, proposes an architecture and analyzes a case study with promising results.

Paper Nr: 61
Title:

A New Paradigm for Web App Development, Deployment, Distribution, and Collaboration

Authors:

Chao Wu and Yike Guo

Abstract: Web application is getting great prosperous while web browser is becoming one of the most important platforms not only on PCs, but also on mobile devices. And web application producing and consuming are going through a process of transformation sharped by the trends including Cloud computing, social networking, online application store, etc. It’s necessary to look at the whole web application paradigm and get vision for its future. In this paper, we gave our insight on the web application paradigm, discussing its aspects of development, deployment, distribution, economic model, cloud platform, social diffusion and so on, and represent both the architecture and implementation based on our understanding.

Paper Nr: 77
Title:

Enhancing Linguistic Web Service Description with Non-functional NLP Properties

Authors:

Nabil Baklouti, Bilel Gargouri and Mohamed Jmaiel

Abstract: This paper deals with the enhancing of LinguisticWeb Service (LingWS) description. It proposes an extension for the OWL-S approach and a Natural Language Processing (NLP) domain ontology based on linguistic standards. The proposed extension provides a classification of the Non-functional NLP properties which promotes the representation of their relationships. The extended OWL-S description is linked to the NLP domain ontology to semantically annotate the LingWS properties.

Paper Nr: 117
Title:

Sip2Share - A Middleware for Mobile Peer-to-Peer Computing

Authors:

Gerardo Canfora and Fabio Melillo

Abstract: The growing success of mobile devices is enabling a new class of applications that overcome the traditional models of desktop applications and web browsing, and embrace entirely new ways of computing. Service oriented computing and the rapidly growing power of mobile devices are the key ingredients of a new generation of low-cost, lightweight applications where mobile devices are no longer intended as a means to access server-side data and functionality, but as a source of services that other devices can discover and invoke. In this paper we introduce Sip2Share, a middleware that allows for publishing, discovering and invoking services in a peer-to-peer network of Android devices. A characteristics of our middleware is that services are advertised, discovered and called using the same native mechanisms of the Android platform, i.e. intent, manifests and broadcast receivers.

Posters
Paper Nr: 3
Title:

Size Measures for Large Web Service Systems

Authors:

Teh Phoey Lee and Geoffrey Muchiri Muketha

Abstract: Web service systems grow larger with age whenever organizations add new services to existing systems. As is the case with other types of software, very large Web service systems are difficult to understand and maintain and are therefore undesirable. A couple of measures have been proposed in literature that can be used to analyze the size attribute of Web service systems with the goal of aiding designers and managers in the management of such software. However, these measures target only simple to medium-sized services, and are not effective for very large cross-enterprise services. In this paper, we propose some size measures for evaluating the size of Web service systems irrespective of their granularity, thereby providing useful information to business process managers. We have validated the measures theoretically using Briand’s measurement framework.

Paper Nr: 104
Title:

Adaptation of Bees Algorithm for QOS-based Selection and Replacement of Web Services

Authors:

Rim Teyeb Jaouachi, Maher Ben Jemaa and Achraf Karray

Abstract: Web service is a new paradigm of internet software and distributed computing. With the growth of web services number, the capability to find the optimal service which can substitute the fault service from different communities represents a very hard operation. The researched service must have the same functionalities of the fault service and the highest quality of service scale. In this paper, we propose heuristic method based onBees Algorithm to find the optimal service which can substitute the fault service. In our approach, we design a distributed environment based on Peer-to-Peer architecture in order to present distributed communities which are considered as flowers and research requests as bees.

Paper Nr: 119
Title:

Data Mining Service Architecture - An Exploration on Self-organizing Software

Authors:

Junpeng Bao, Bin Tao, Jie Su and Hui He

Abstract: Software as a Service (SaaS) becomes a very important trend in software engineering. In order to practice the principles of SasS and Service Oriented Architecture (SOA), we introduce a concept of Self-Organizing Software (SOS) and a simple prototype implementation, called Data Mining Service Architecture (DMS Arc) in the paper. SOS implies that the software will automatically build and accomplish the executive entity according to the user requirements. The DMS Arc is a knowledge based service composition system that aims to encapsulate basic Data Mining functions into meta services and automatically combine those services according to the stored knowledge models to fulfil a specific Data Mining requirement. We present some key issues that place in the SOS service cycle. The DMS Arc project is still on developing, and will be published as a public facility in a Cloud Computing environment.

Paper Nr: 120
Title:

An Agile Approach for Service-Oriented Architectures

Authors:

Hamza Chehili, Mahmoud Boufaida and Lionel Seinturier

Abstract: Today, service oriented architectures (SOA) has received much interest. the need of methodologies for the implementation of this architecture is very critical and crucial. In this position paper, we present an agile approach for the development of SOA with the respect of the principles of agile methods. This approach exploits the BPMN model to design incrementally business processes and the SCA model to describe the business functions of the system as an assembly of components. As implementation of this approach, we announce briefly a computer aided software engineering (CASE) framework.

Area 4 - Context

Full Papers
Paper Nr: 106
Title:

Context Modeling and Context Transition Detection in Software Development

Authors:

Bruno Antunes, Joel Cordeiro and Paulo Gomes

Abstract: As software development projects increase in size and complexity, developers are becoming overloaded and need to cope with a growing amount of contextual information. This information can be captured and processed in order to improve some of the tasks performed by developers during their work. We propose a context model that represents the focus of attention of the developer at each moment. This context model adapts to changes in the focus of attention of the developer through the automatic detection of context transitions. We have developed a prototype that was submitted to an experiment with a group of developers, to collect statistical information about the context modeling process and to manually validate the context transition mechanism.

Short Papers
Paper Nr: 33
Title:

Tamil Characters Recognition and Retrieval

Authors:

Abdol Hamid Pilevar

Abstract: In this paper the shape of the vertical projection curves are considered. The behavior of the edges of vertical projection curve is selected for creating the feature vectors of the characters. The edges of the vertical projection curve traced and the direction of the movement in the edges has been mapped by Eleven Direction Method (EDM) method .The direction codes have been extracted and saved as features vectors of the characters. The method is tested on the Tamil printed text documents. The testing data are collected from various legal documents. The test documents contain alphabet, special characters. A technique named EDM is used to search and retrieve the characters from Tamil text databases. The effectiveness and performance of the proposed algorithm have been tested with 10 separate sample data of 6 different fonts. The experiments shows that more than 97% of the Tamil characters are recognized correctly therefore, the proposed algorithm and the selected features perform satisfactorily.

Paper Nr: 46
Title:

A Synthesis of a Knowledge Management Framework for Sports Event Management

Authors:

Azizul Rahman Abdul Ghaffar, Ghassan Beydoun, Jun Shen, Will Tibben and Dongming Xu

Abstract: Due to rapid social development in Asia, sports events have grown larger and many new countries are also hosting them for their first time. In addition to required increase in expenditures and more efficient management, various instances of inadequate planning highlighted the needs for more effective and better sustainable structures to support knowledge transfer between organizers, from one event to the next. The research presented in this paper aims to facilitate the deployment of systematic knowledge management practices to sports event management, to enable sustainable planning. The research in this paper synthesizes is carried out on the Malaysian Games as an example of a sports event management. Furthermore, we introduce knowledge management (KM) framework that was developed based on studies and observations of processes and activities in this organization. The focus is on knowledge that is key to the success of the Malaysian Games and that which can be used to the development of the organization and in future games.

Paper Nr: 93
Title:

Enhancing Alternative and Augmentative Communications Devices with Context Awareness Computing

Authors:

Adam Loup, Lindsay Blue and Shengru Tu

Abstract: The paper reports the development of a software framework that assists programmers to enhance Alternative and Augmentative Communications (AAC) devices by applying context awareness technologies. Based on the situational contexts including the location and the categories of the conversation, the enhanced system can be highly personalized and can filter, sort the words internally and highlight the words in display. The objective is to lessen the burden of device-aided communication by proactively delivering situational dependent words derived from historical usage contexts.

Paper Nr: 98
Title:

Knowledge Provisioning - A Context-sensitive Process-oriented Approach Applied to Software Engineering Environments

Authors:

Gregor Grambow, Roy Oberhauser and Manfred Reichert

Abstract: Software development is a complex, dynamic, and highly intellectual process that provides automation challenges in the areas of process and knowledge management. Moreover, the ability to support the context-sensitive provisioning of knowledge is further exacerbated by the rapidly changing technologies, processes, knowledge, practices, methods, and tool chains that software engineering involves. Thus, the effective and timely provisioning of knowledge and its concrete utilization in the software development process remains problematic. Reasons for this include the need to ascertain the context, to be aware of the process, and to reason and select the appropriate knowledge to provision while abiding by human and other constraints. For such dynamic knowledge and process environments, this paper describes an approach for realizing a knowledge-based system that automatically provisions knowledge aligned with both the actual context (user, process, and project) and with automated workflow governance. To demonstrate the feasibility of the approach, a scenario-based application of the implementation to the software engineering domain is shown.