Yves Wautelet

Unifying and Extending user Story Models

Within Agile methods, User Stories (US) are mostly used as primary requirements artifacts and units of functionality of the project. The idea is to express requirements on a low abstraction basis using natural language. Most of them are exclusively centered on the final user as only stakeholder. Over the years, some templates (in the form of concepts relating the WHO, WHAT and WHY dimensions into a phrase) have been proposed by agile methods practitioners or academics to guide requirements gathering. Using these templates can be problematic. Indeed, none of them define any semantic related to a particular syntax precisely or formally leading to various possible interpretations of the concepts. Consequently, these templates are used in an ad–hoc manner, each modeler having idiosyncratic preferences. This can nevertheless lead to an underuse of representation mechanisms, misunderstanding of a concept use and poor communication between stakeholders. This paper studies templates found in literature in order to reach unification in the concepts’ syntax, an agreement in their semantics as well as methodological elements increasing inherent scalability of US-based projects.

Agent-Based user interface generation from combined task, context and domain models

User interfaces (UI) for data systems has been a technical and human interaction research question for a long time. Today these user interfaces require dynamic automation and run-time generation to properly deal with on a large-scale. This paper presents an agent-based framework, i.e., a methodological process, a meta-model and a computer software to drive the automatic database user interface design and code behind generation from the task model, context model and domain model combined together. This includes both the user interface and the basic functions of the database application.

A Process for Developing Adaptable and Open Service Systems: Application in Supply Chain Management

Service-oriented computing is becoming increasingly popular. It allows designing flexible and adaptable software systems that can be easily adopted on demand by software customers. Those benefits are from primary importance in the context of supply chain management; that is why this paper proposes to apply ProDAOSS, a process for developing adaptable and open service systems to an industrial case study in outbound logistics. ProDAOSS is conceived as a plug-in for I-Tropos - a broader development methodology - so that it covers the whole software development life cycle. At analysis level, flexible business processes were generically modelled with different complementary views. First of all, an aggregate services view of the whole applicative package is offered; then services are split using an agent ontology - through the i* framework - to represent it as an organization of agents. A dynamic view completes the documentation by offering the service realization paths. At design stage, the service center architecture proposes a reference architectural pattern for services realization in an adaptable and open manner.

Social Structure Based Design Patterns for Agent-Oriented Software Engineering

Multi-agent systems (MAS) architectures are gaining popularity over traditional ones for building open, distributed, and evolving software required by today’s corporate IT applications such as e-business systems, Web services, or enterprise knowledge bases. Since the fundamental concepts of multi-agent systems are social and intentional rather than object, functional, or implementation-oriented, the design of MAS architectures can be eased by using social patterns. They are detailed agent-oriented design idioms to describe MAS architectures composed of autonomous agents that interact and coordinate to achieve their intentions, like actors in human organizations. This article presents social patterns and focuses on a framework aimed to gain insight into these patterns. The framework can be integrated into agent-oriented software engineering methodologies used to build MAS. We consider the Broker social pattern to illustrate the framework. An overview of the mapping from system architectural design (through organizational architectural styles), to system detailed design (through social patterns), is presented with a data integration case study. The automation of creating design patterns is also discussed.

Bridging User Story Sets with the Use Case Model

User Stories (US) are mostly used as basis for representing requirements in agile development. Written in a direct manner, US fail in producing a visual representation of the main system-to-be functions. A Use-Case Diagram (UCD), on the other hand, intends to provide such a view. Approaches that map US sets to a UCD have been proposed; they however consider every US as a Use Case (UC). Nevertheless, a valid UC should not be an atomic task or a sub-process but enclose an entire scenario of the system use instead. A unified model of US templates to tag US sets was previously build. Within functional elements, it notably distinguishes granularity levels. In this paper, we propose to transform specific elements of a US set into a UCD using the granularity information obtained through tagging. In practice, such a transformation involves continuous round-tripping between the US and UC views; a CASE-tool supports this.

Requirements-Driven Iterative Project Planning

Organizational modeling with the i* framework has widely been used for model-driven software development adopting a transformational approach, notably within the Tropos process. Its high-level representation elements allow to partition the software problem into adequate and manageable elements (actors, goals, tasks, resources and dependencies) leading to an agent-oriented design, and eventually an implementation with agent technologies (JACK, Jadex, Chimera Agent, ...). This paper proposes to use the i* framework for iterative software planning; each of the goals from the i* strategic dependency model are evaluated on the basis of the (high-level) threats they face and the expected quality factors. This allows to determine a priority among the model goals and “feed” an iterative template to plan the whole project realization. This framework is thus meant to be applied during the first iteration of the project for model-driven software project management. The development of a production management system in the steel industry is used as an example.

Building a rationale diagram for evaluating user story sets

Requirements representation in agile methods is often done on the basis of User Stories (US) which are short sentences relating a WHO, WHAT and (possibly) WHY dimension. They are by nature very operational and simple to understand thus very efficient. Previous research allowed to build a unified model for US templates associating semantics to a set of keywords based on templates collected over the web and scientific literature. Since the semantic associated to these keywords is mostly issued of the i* framework we overview in this paper how to build a custom rationale diagram on the basis of a US set tagged using that unified template. The rationale diagram is strictly speaking not an i* strategic rationale diagram but uses parts of its constructs and visual notation to build various trees of relating US elements in a single project. Indeed, the benefits of editing such a rationale diagram is to identify depending US, identifying EPIC ones and group them around common Themes. The paper shows the feasibility of building the rationale diagram, then points to the use of these consistent sets of US for iteration content planning. To ensure the US set and the rationale diagram constitute a consistent and not concurrent whole, an integrated Computer-Aided Software Engineering (CASE) tool supports the approach.

A Service-Oriented Framework for Component-Based Software Development: An i* Driven Approach

Optimizing is a fundamental concept in our modern mature economy. Software development also follows this trend and, as a consequence, new techniques are appearing over the years. Among those we find services oriented computing and component based development. The first gives the adequate structure and flexibility required in the development of large industrial software developments, the second allows recycling of generically developed code. This paper is at the borders of these paradigms and constitutes an attempt to integrate components into service-oriented modelling. Indeed, when developing huge multi-actor application packages, solutions to specific problems should be custom developed while others can be found in third party offers. FaMOS-C, the framework proposed in this paper, allows modelling such problems and directly integrates a selection process among different components based on their performance in functional and non-functional aspects. The framework is firstly depicted and then evaluated on a case study in supply chain management.

User-story driven development of multi-agent systems: A process fragment for agile methods

Abstract Agile software development methods are mostly built as a set of managerial guidelines and development concepts on how to handle a software development but are not bounded to software development paradigms like object or agent orientation. Some methods, like eXtreme Programming and SCRUM are driven by operational requirements representation models called User Stories. These User Stories can be used as an anchoring point to agile methods; this means that we could take a User Stories set to drive a software transformation approach embedded in a particular development paradigm. This paper presents a process fragment for Multi-Agent Systems development with agile methods based on User Stories sets. The process fragment indeed takes advantage of an initial set of User Stories to build a reasoning model (called the Rationale Tree; typically several of these are built for a single project) that documents decompositions and means-end alternatives in scenarios for requirements realization. A Rationale Tree can then be aligned with a Multi-Agent design and implemented in an agent-oriented development language. In this paper the transformation is targeted to the JAVA Agent DEvelopment (JADE) framework. The process fragment (at least partially) covers the Requirements Analysis, Multi-Agent System Design and Multi-Agent System Implementation phases. Transformation from one phase to the other is overseen and illustrated on an example.

Representing, Modeling and Engineering a Collaborative Supply Chain Management Platform

Global optimization among partners of a supply chain is a trend often found in scientific literature. To achieve such a result, technological tools to collect suitable information within shortest delays are required. Devices such as RFID or GPS positioning systems deliver real-time information on material flows. However, data fragments need to be integrated in a global information sharing system where each of the involved actors can perform computations as well as operations to take autonomous action and manage resources at best. In this perspective, the paper presents a research aimed to build an e-collaborative software system for outbound logistic actors. Advanced knowledge representation models are used, notably a framework driven by the core services provided by the involved actors and structured using the classical three decision layers. The actor’s rationale is then detailed which further leads to the design of a multi-agent system. The proposal is validated using a critical success factors framework for IT evaluation in SCM.