The Experts below are selected from a list of 275457 Experts worldwide ranked by ideXlab platform

John Mylopoulos - One of the best experts on this subject based on the ideXlab platform.

  • GaiusT: supporting the extraction of rights and obligations for regulatory compliance
    Requirements Engineering, 2015
    Co-Authors: Nicola Zeni, Nadzeya Kiyavitskaya, Luisa Mich, James R. Cordy, John Mylopoulos
    Abstract:

    Ensuring compliance of software systems with government regulations, policies, and laws is a complex problem. Generally speaking, solutions to the problem first identify rights and obligations defined in the law and then treat these as Requirements for the system under design. This work examines the challenge of developing tool support for extracting such Requirements from legal documents. To address this challenge, we have developed a tool called GaiusT. The tool is founded on a framework for textual semantic annotation. It semiautomatically generates elements of Requirements Models, including actors, rights, and obligations. We present the complexities of annotating prescriptive text, the architecture of GaiusT, and the process by which annotation is accomplished. We also present experimental results from two case studies to illustrate the application of the tool and its effectiveness relative to manual efforts. The first case study is based on the US Health Insurance Portability and Accountability Act, while the second analyzes the Italian accessibility law for information technology instruments.

  • towards augmenting Requirements Models with preferences
    Automated Software Engineering, 2009
    Co-Authors: Sotirios Liaskos, Sheila A Mcilraith, John Mylopoulos
    Abstract:

    The analysis of stakeholder Requirements is a critical aspect of software engineering. A common way of specifying stakeholder Requirements is in terms of a hierarchy of goals whose AND/OR decomposition captures a family of software solutions that comply with the goals. In this paper, we extend this goal modeling framework to include the specification of optional user Requirements and user preferences, aggregated together into weighted formulae to be optimized. We team this with an automated reasoning tool, adapted from state of the art research in artificial intelligence planning with preferences, in order to synthesize solutions that both comply with the goals and optimize stakeholder preferences and optional Requirements.

  • an architecture for Requirements driven self reconfiguration
    Conference on Advanced Information Systems Engineering, 2009
    Co-Authors: Fabiano Dalpiaz, Paolo Giorgini, John Mylopoulos
    Abstract:

    Self-reconfiguration is the capability of a system to autonomously switch from one configuration to a better one in response to failure or context change. There is growing demand for software systems able to self-reconfigure, and specifically systems that can fulfill their Requirements in dynamic environments. We propose a conceptual architecture that provides systems with self-reconfiguration capabilities, enacting a model-based adaptation process based on Requirements Models. We describe the logical view on our architecture for self-reconfiguration, then we detail the main mechanisms to monitor for and diagnose failures. We present a case study where a self-reconfiguring system assists a patient perform daily tasks, such as getting breakfast, within her home. The challenge for the system is to fulfill its mission regardless of the context, also to compensate for failures caused by patient inaction or other omissions in the environment of the system.

  • Designing socio-technical systems: from stakeholder goals to social networks
    Requirements Engineering, 2009
    Co-Authors: Volha Bryl, Paolo Giorgini, John Mylopoulos
    Abstract:

    Software systems are becoming an integral part of everyday life influencing organizational and social activities. This aggravates the need for a socio-technical perspective for Requirements engineering, which allows for modelling and analyzing the composition and interaction of hardware and software components with human and organizational actors. In this setting, alternative Requirements Models have to be evaluated and selected finding a right trade-off between the technical and social dimensions. To address this problem, we propose a tool-supported process of Requirements analysis for socio-technical systems, which adopts planning techniques for exploring the space of Requirements alternatives and a number of social criteria for their evaluation. We illustrate the proposed approach with the help of a case study, conducted within the context of an EU project.

  • ER - Designing Law-Compliant Software Requirements
    Conceptual Modeling - ER 2009, 2009
    Co-Authors: Alberto Siena, Anna Perini, John Mylopoulos, Angelo Susi
    Abstract:

    New laws, such as HIPAA and SOX, are increasingly impacting the design of software systems, as business organisations strive to comply. This paper studies the problem of generating a set of Requirements for a new system which comply with a given law. Specifically, the paper proposes a systematic process for generating law-compliant Requirements by using a taxonomy of legal concepts and a set of primitives to describe stakeholders and their strategic goals. Given a model of law and a model of stakeholders goals, legal alternatives are identified and explored. Strategic goals that can realise legal prescriptions are systematically analysed, and alternative ways of fulfilling a law are evaluated. The approach is demonstrated by means of a case study. This work is part of the Nomos framework, intended to support the design of law-compliant Requirements Models.

A Van Lamsweerde - One of the best experts on this subject based on the ideXlab platform.

  • deriving tabular event based specifications from goal oriented Requirements Models
    IEEE International Conference on Requirements Engineering, 2003
    Co-Authors: Renaud De Landtsheer, Emmanuel Letier, A Van Lamsweerde
    Abstract:

    Goal-oriented methods are increasingly popular for elaborating software Requirements. They provide systematic support for incrementally building intentional, structural and operational Models of the software and its environment together with various techniques for early analysis, e.g., to manage conflicting goals or anticipate abnormal environment behaviors that prevent goals from being achieved. On the other hand, tabular event-based methods are well-established for specifying operational Requirements for control software. They provide sophisticated techniques and tools for late analysis of software behavior Models through, e.g., simulation, model checking or table exhaustiveness checks. We propose to take the best out of these two worlds to engineer Requirements for control software. It presents a technique for deriving event-based specifications, written in the SCR tabular language, from operational specifications built according to the KAOS goal-oriented method. The technique consists in a series of transformation steps each of which resolves semantic, structural or syntactic differences between the KAOS source language and the SCR target language. Some of these steps need human intervention and illustrate the kind of semantic subtleties that need to be taken into account when integrating multiple formalisms. As a result of our technique SCR specifiers may use upstream goal-based processes a la KAOS for the incremental elaboration, early analysis, organization and documentation of their tables while KAOS modelers may use downstream tables a la SCR for later analysis of the behavior Models derived from goal specifications.

Walter F. Tichy - One of the best experts on this subject based on the ideXlab platform.

  • From Requirements to UML Models and back: how automatic processing of text can support Requirements engineering
    Software Quality Journal, 2014
    Co-Authors: Mathias Landhäußer, Sven J. Körner, Walter F. Tichy
    Abstract:

    Software engineering is supposed to be a structured process, but manual tasks leave much leeway. Ideally, these tasks lie in the hands of skilled analysts and software engineers. This includes creating the textual specification of the envisioned system as well as creating Models for the software engineers. Usually, there is quite a bit of erosion during the process due to requirement changes, implementation decisions, etc. To deliver the software as specified, textual Requirements, Models, and the actual software need to be synchronized. However, in practice, the cost of manually maintaining consistency is too high. Our Requirements engineering feedback system automates the process of keeping textual specification and Models consistent when the Models change. To improve overall processing of natural language specifications, our approach finds flaws in natural language specifications. In addition to the already published workshop paper, we show how well our tools support even non-software-engineers in improving texts. The case studies show that we can speed up the process of creation texts with fewer flaws significantly.

  • How Automatic Processing of Text Can Support Requirements Engineering
    2013
    Co-Authors: Walter F. Tichy
    Abstract:

    Software engineering is supposed to be a structured process, but manual tasks leave much leeway. Ideally, these tasks lie in the hands of skilled analysts and software engineers. This includes creating the textual speci- cation of the envisioned system as well as creating Models for the software engineers. Usually, there is quite a bit of erosion during the process due to requirement changes, implementation decisions, etc. To deliver the software as specied, textual Requirements, Models, and the actual software need to be synchronized. However, in practice the cost of manually maintaining con- sistency is too high. Our Requirements Engineering Feedback System (REFS) automates the process of keeping textual specication and Models consistent when the Models change. To improve overall processing of natural language specications,

Renaud De Landtsheer - One of the best experts on this subject based on the ideXlab platform.

  • Deriving tabular event-based specifications from goal-oriented Requirements Models
    Requirements Engineering, 2004
    Co-Authors: Renaud De Landtsheer, Emmanuel Letier, Axel Van lamsweerde
    Abstract:

    Goal-oriented methods are increasingly popular for elaborating software Requirements. They offer systematic support for incrementally building intentional, structural and operational Models of the software and its environment. They also provide various techniques for early analysis, notably, to manage conflicting goals or to anticipate abnormal environment behaviours that prevent goals from being achieved. On the other hand, tabular event-based methods are well-established for specifying operational Requirements for control software. They provide sophisticated techniques and tools for late analysis of software behaviour Models through simulation, model checking or table exhaustiveness checks. The paper proposes to take the best out of these two worlds to engineer Requirements for control software. It presents a technique for deriving event-based specifications, written in the SCR tabular language, from operational specifications built according to the KAOS goal-oriented method. The technique consists of a series of transformation steps each of which resolves semantic, structural or syntactic differences between the KAOS source language and the SCR target language. Some of these steps need human intervention and illustrate the kind of semantic subtleties that need to be taken into account when integrating multiple formalisms. As a result of our technique SCR specifiers may use upstream goal-based processes à la KAOS for the incremental elaboration, early analysis, organization and documentation of their tables, while KAOS modelers may use downstream tables à la SCR for later analysis of the behaviour Models derived from goal specifications.

  • deriving tabular event based specifications from goal oriented Requirements Models
    IEEE International Conference on Requirements Engineering, 2003
    Co-Authors: Renaud De Landtsheer, Emmanuel Letier, A Van Lamsweerde
    Abstract:

    Goal-oriented methods are increasingly popular for elaborating software Requirements. They provide systematic support for incrementally building intentional, structural and operational Models of the software and its environment together with various techniques for early analysis, e.g., to manage conflicting goals or anticipate abnormal environment behaviors that prevent goals from being achieved. On the other hand, tabular event-based methods are well-established for specifying operational Requirements for control software. They provide sophisticated techniques and tools for late analysis of software behavior Models through, e.g., simulation, model checking or table exhaustiveness checks. We propose to take the best out of these two worlds to engineer Requirements for control software. It presents a technique for deriving event-based specifications, written in the SCR tabular language, from operational specifications built according to the KAOS goal-oriented method. The technique consists in a series of transformation steps each of which resolves semantic, structural or syntactic differences between the KAOS source language and the SCR target language. Some of these steps need human intervention and illustrate the kind of semantic subtleties that need to be taken into account when integrating multiple formalisms. As a result of our technique SCR specifiers may use upstream goal-based processes a la KAOS for the incremental elaboration, early analysis, organization and documentation of their tables while KAOS modelers may use downstream tables a la SCR for later analysis of the behavior Models derived from goal specifications.

Sebastian Uchitel - One of the best experts on this subject based on the ideXlab platform.

  • risk driven revision of Requirements Models
    International Conference on Software Engineering, 2016
    Co-Authors: Dalal Alrajeh, Axel Van Lamsweerde, Jeff Kramer, Alessandra Russo, Sebastian Uchitel
    Abstract:

    Requirements incompleteness is often the result of unanticipated adverse conditions which prevent the software and its environment from behaving as expected. These conditions represent risks that can cause severe software failures. The identification and resolution of such risks is therefore a crucial step towards Requirements completeness. Obstacle analysis is a goal-driven form of risk analysis that aims at detecting missing conditions that can obstruct goals from being satisfied in a given domain, and resolving them. This paper proposes an approach for automatically revising goals that may be under-specified or (partially) wrong to resolve obstructions in a given domain. The approach deploys a learning-based revision methodology in which obstructed goals in a goal model are iteratively revised from traces exemplifying obstruction and non-obstruction occurrences. Our revision methodology computes domain-consistent, obstruction-free revisions that are automatically propagated to other goals in the model in order to preserve the correctness of goal Models whilst guaranteeing minimal change to the original model. We present the formal foundations of our learning-based approach, and show that it preserves the properties of our formal framework. We validate it against the benchmarking case study of the London Ambulance Service.

  • Deriving event-based transition systems from goal-oriented Requirements Models
    AUTOMAT SOFTW ENG, 2008
    Co-Authors: Sebastian Uchitel
    Abstract:

    Goal-oriented methods are increasingly popular for elaborating software Requirements. They offer systematic support for incrementally building intentional, structural, and operational Models of the software and its environment. Event-based transition systems on the other hand are convenient formalisms for reasoning about software behaviour at the architectural level.The paper relates these two worlds by presenting a technique for translating formal specification of software operations built according to the KAOS goal-oriented method into event-based transition systems analysable by the LTSA toolset. The translation involves moving from a declarative, state-based, timed, synchronous formalism typical of Requirements modelling languages to an operational, event-based, untimed, asynchronous one typical of architecture description languages. The derived model can be used for the formal analysis and animation of KAOS operation Models in LTSA.The paper also provides insights into the two complementary formalisms, and shows that the use of synchronous temporal logic for Requirements specification hinders a smooth transition from Requirements to software architecture Models.