From Textual Use-Cases to Component-Based Applications

  title={From Textual Use-Cases to Component-Based Applications},
  author={V. Simko and P. Hnetynka and T. Bures},
  booktitle={SNPD 2010},
A common practice to capture functional requirements of a software system is to utilize use-cases, which are textual descriptions of system usage scenarios written in a natural language. Since the substantial information about the system is captured by the use-cases, it comes as a natural idea to generate from these descriptions the implementation of the system (at least partially). However, the fact that the use-cases are in a natural language makes this task extremely difficult. In this paper… Expand
Runtime semantics of use case stories
This paper introduces a new software development approach where stories written in commonly understood structured natural language gain runtime semantics, and proposes precise translational semantics for such defined stories. Expand
Translation of Use Case Scenarios to Java Code
It is shown that use case scenarios can gain precise metamodel-based notation and semantics enabling automatic processing, and transformation algorithms that can transform use cases scenarios directly to dynamic code in Java are shown. Expand
Computer Science
Use cases are usually treated as second class citizens in the software development chain based on models. Their textual descriptions (scenarios) are treated as informal input to more formal designExpand
Requirements-level language and tools for capturing software system essence
A model-based language for comprehensive treatment of domain knowledge, expressed through constrained natural language phrases that are grouped by nouns and include verbs, adjectives and prepositions is proposed. Expand
Using structured grammar domain models to capture software system essence
This paper presents initial tooling framework to capture application logic specifications and make them available for further automated transformations and proposes a model-based language for comprehensive treatment of domain knowledge, expressed through constrained natural language phrases that are grouped by nouns and include verbs, adjectives and prepositions. Expand
From Requirements to Java in a Snap
A library of anti-patterns can be built and used as guidance to avoid certain commonly made mistakes in use case modelling, and especially in Sect. Expand
Towards an Automated Requirements-driven Development of Smart Cyber-Physical Systems
This paper analyzes the translation process of natural language requirements into the IRM-SA model, identifies individual steps that can be automated and/or validated using natural language processing techniques, and proposes suitable methods. Expand
SimCo - Hybrid Simulator for Testing of Component Based Applications
An approach to discrete event simulation testing of components and component sets that can execute a mixture of real, implemented components and simulated mock-ups of the remaining parts of the application, which allows faster testing on a wide scale of different inputs for tested components. Expand
������������������������� ������������������� ����������� ���������������� ������ �������� ������ ��������� ������ ���������� ������������������������ ���������� �������������� ���� ����������� �Expand
From textual specification to formal verification


Automated Code Generation from System Requirements in Natural Language
An approach that allows automated generation of executable code directly from the use cases written in a natural language and makes immediate verification of requirements completeness possible and the generated code can be used as a starting point for the final implementation. Expand
This paper describes how the principal attributes of the action described by a use case step can be acquired from theparse tree of the sentence specifying the step; it employs readily available linguistic tools for obtaining the parse tree. Expand
Improved Processing of Textual Use Cases: Deriving Behavior Specifications
This work proposes a new method for processing textual requirements based on the scheme earlier described in [13], which allows to process the commonly used complex sentence structures, obtaining more descriptive behavior specifications, which may be used to verify and validate requirements and to derive the initial design of the system. Expand
On the Systematic Analysis of Natural Language Requirements with CIRCE
Circe is presented, an environment for the analysis of natural language requirements, based on a transformational paradigm, and an expert system based on modular agents, embodying intensional knowledge about software systems in general is presented. Expand
Higher quality requirements specifications through natural language patterns
This work presents an approach for reducing the problem of imprecision in natural language requirements specifications with the use of natural language patterns, which allow formulating requirements sentences in a less ambiguous, more complete, and more accurate way. Expand
Getting 'whole Picture' Behavior in a Use Case Model
A simple formal model Generic UC View is introduced which identifies important abstractions and the relations upon them which target the goal and the concept of use case expression is the base for the desired reasoning on whether the behavior of an entity complies with the composed behavior of its sub-entities. Expand
Autonomous Requirements Specification Processing using Natural Language Processing
The use of NLP in the requirements analysis and systems design processes is addressed and a prototype toolset that can assist the systems analyst or software engineer to select and verify terms relevant to a project is developed. Expand
ATL: a QVT-like transformation language
ATL is presented: a QVT-like model transformation language and its execution environment based on the Eclipse framework and the availability of high quality tool support is also of major importance for the industrial adoption and ultimate success of MDE. Expand
Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Edition)
Building on two widely acclaimed previous editions, Craig Larman has updated this book to fully reflect the new UML 2 standard, to help you master the art of object design, and to promote high-impact, iterative, and skillful agile modeling practices. Expand
Behavior Protocols for Software Components
Using the definitions of bounded component behavior and protocol conformance relation, the designer can verify the adherence of a component's implementation to its specification at runtime, while the correctness of refining the specification can be verified at design time. Expand