Generating natural language specifications from UML class diagrams

Early phases of software development are known to be problematic, difficult to manage and errors occurring during these phases are expensive to correct. Many systems have been developed to aid the transition from informal Natural Language requirements to semistructured or formal specifications. Furthermore, consistency checking is seen by many software engineers as the solution to reduce the number of errors occurring during the software development life cycle and allow early verification and validation of software systems. However, this is confined to the models developed during analysis and design and fails to include the early Natural Language requirements. This excludes proper user involvement and creates a gap between the original requirements and the updated and modified models and implementations of the system. To improve this process, we propose a system that generates Natural Language specifications from UML class diagrams. We first investigate the variation of the input language used in naming the components of a class diagram based on the study of a large number of examples from the literature and then develop rules for removing ambiguities in the subset of Natural Language used within UML. We use WordNet,a linguistic ontology, to disambiguate the lexical structures of the UML string names and generate semantically sound sentences. Our system is developed in Java and is tested on an independent though academic case study

Comparison of Z and UML: Two Case Studies

Specification languages usually can provide simple abstract descriptions of complex behaviors of software systems. A large number of specification languages have been introduced for software development. One categorization of specification languages is formal vs. informal. Z and UML are the well-known formal and informal objectoriented specification languages, respectively. In this thesis, related work on Z and UML is reviewed. An overview of Z and UML is also provided. Z and UML are compared from the language aspects based on a set of criteria. In order to provide a practical basis, Z and UML are also compared, based on another set of criteria, using two classic case studies: the library database system and the elevator concurrent control system. The results of the comparison carried out in this thesis are listed. Z is a formal specification language. Specifications in Z are abstract and are based on mathematical definition. Z is mature and there are lots of tools to support it. UML is an informal objectoriented specification language. UML notations are icons, graphics, and English. Specifications in UML are easy to understand, but have the potential to be ambiguous. UML is getting more popular now and there are lots of tools to support UML. In addition to the theoretical comparison, Z and UML are compared using two classic case studies: the library database system and the elevator concurrent control system. The practical experience revealed that UML provided a good approach to modeling the main concepts using use case diagrams, collaboration diagrams, and state diagrams, while Z provided a precise model for specification of the problem. Z and UML appear to be complementary. Combining Z and UML in different phases and aspects is the recommended approach

A Method and Support Tool for Animation of Informal Specifications in Functional Requirements Analysis

Requirements analysis based on informal textual specifications is a common practice in industry. The reason is that the specifications is easy understanding for a user who is not familiar with technique of software design or development. However, how to ensure that it is accurately and effectively done still remains a challenge due to the limitation in communication between the user and the analyst. In this paper, we describe a software tool that supports the automatic transformation from a SOFL informal specification to UML use case diagrams and the animation of each function based on its input and output. The tool also provides various editing functions for the use case diagrams to support interactive efforts in improving the expression of the use case diagrams. The reason why we choose use case diagrams is because the diagrams is similar with SOFL informal specifications in that the diagram is used in requirements analysis or definition and the diagram focus on systems of functions. The reason why the tool animate functions based on its input and output is that the SOFL semi-formal or formal specifications are describe inputs and outputs of function, but informal specifications are not

A thread-tag based semantics for sequence diagrams

The sequence diagram is one of the most popular behaviour modelling languages which offers an intuitive and visual way of describing expected behaviour of object-oriented software. Much research work has investigated ways of providing a formal semantics for sequence diagrams. However, these proposed semantics may not properly interpret sequence diagrams when lifelines do not correspond to threads of controls. In this paper, we address this problem and propose a thread-tag based sequence diagram as a solution. A formal, partially ordered multiset based semantics for the thread-tag based sequence diagrams is proposed

Formalization and Validation of Safety-Critical Requirements

The validation of requirements is a fundamental step in the development process of safety-critical systems. In safety critical applications such as aerospace, avionics and railways, the use of formal methods is of paramount importance both for requirements and for design validation. Nevertheless, while for the verification of the design, many formal techniques have been conceived and applied, the research on formal methods for requirements validation is not yet mature. The main obstacles are that, on the one hand, the correctness of requirements is not formally defined; on the other hand that the formalization and the validation of the requirements usually demands a strong involvement of domain experts. We report on a methodology and a series of techniques that we developed for the formalization and validation of high-level requirements for safety-critical applications. The main ingredients are a very expressive formal language and automatic satisfiability procedures. The language combines first-order, temporal, and hybrid logic. The satisfiability procedures are based on model checking and satisfiability modulo theory. We applied this technology within an industrial project to the validation of railways requirements

Generating a Performance Stochastic Model from UML Specifications

Since its initiation by Connie Smith, the process of Software Performance Engineering (SPE) is becoming a growing concern. The idea is to bring performance evaluation into the software design process. This suitable methodology allows software designers to determine the performance of software during design. Several approaches have been proposed to provide such techniques. Some of them propose to derive from a UML (Unified Modeling Language) model a performance model such as Stochastic Petri Net (SPN) or Stochastic process Algebra (SPA) models. Our work belongs to the same category. We propose to derive from a UML model a Stochastic Automata Network (SAN) in order to obtain performance predictions. Our approach is more flexible due to the SAN modularity and its high resemblance to UML' state-chart diagram

The pros and cons of using SDL for creation of distributed services

In a competitive market for the creation of complex distributed services, time to market, development cost, maintenance and flexibility are key issues. Optimizing the development process is very much a matter of optimizing the technologies used during service creation. This paper reports on the experience gained in the Service Creation projects SCREEN and TOSCA on use of the language SDL for efficient service creation