A Comparative Study on Transformation of UML/OCL to Other Specifications

2020 ◽  
Vol 13 (2) ◽  
pp. 256-264
Author(s):  
Jagadeeswaran Thangaraj ◽  
Senthilkumaran Ulaganathan
Keyword(s):  
Software Design ◽  
Code Generation ◽  
Formal Specification ◽  
Software Systems ◽  
Software System ◽  
Object Constraint Language ◽  
Modelling Language ◽  
Static Verification ◽  
Implementation Phase ◽  
Automatic Code

Background: Static verification is a sound programming methodology that permits automated reasoning about the correctness of an implementation with respect to its formal specification before its execution. Unified Modelling Language is most commonly used modelling language which describes the client’s requirement. Object Constraint Language is a formal language which allows users to express textual constraints regarding the UML model. Therefore, UML/OCL express formal specification and helps the developers to implement the code according to the client’s requirement through software design. Objective: This paper aims to compare the existing approaches generating Java, C++, C# code or JML, Spec# specifications from UML/OCL. Methods: Nowadays, software system is developed via automatic code generation from software design to implementation when using formal specification and static analysis. In this paper, the study considers transformation from design to implementation and vice versa using model transformation, code generation or other techniques. Results: The related tools, which generate codes, do not support verification at the implementation phase. On the other hand, the specification generation tools do not generate all the required properties which are needed for verification at the implementation phase. Conclusion: If the generated system supports the verification with all required properties, code developer needs less efforts to produce correct software system. Therefore, this study recommends introducing a new framework which can act as an interface between design and implementation to generate verified software systems.

SOFTWARE RELIABILITY ESTIMATIONS THROUGH USAGE ANALYSIS OF SPECIFICATIONS AND DESIGNS

1996 ◽  
Vol 03 (02) ◽  
pp. 101-117
Author(s):  
CLAES WOHLIN ◽  
ANDERS WESSLÉN ◽  
PER RUNESON
Keyword(s):  
Software Design ◽  
Software Reliability ◽  
Formal Specification ◽  
Development Process ◽  
Early Stage ◽  
Software Systems ◽  
Implementation Phase ◽  
Failure Data ◽  
Full Analysis ◽  
Usage Analysis

This paper presents a method proposal for estimation of software reliability before the implementation phase. The method is based upon that a formal specification technique is used and that it is possible to develop a tool performing dynamic analysis, i.e., locating semantic faults in the design. The analysis is performed with both applying a usage profile as input as well as doing a full analysis, i.e., locate all faults that the tool can find. The tool must provide failure data in terms of time since the last failure was detected. The mapping of the dynamic failures to the failures encountered during statistical usage testing and operation is discussed. The method can be applied either on the software specification or as a step in the development process by applying it on the software design. The proposed method allows for software reliability estimations that can be used both as a quality indicator, and for planning and controlling resources, development times, etc. at an early stage in the development of software systems.

scholarly journals Model Based Software Development: Issues & Challenges

2013 ◽  
pp. 84-88
Author(s):  
N Md Jubair Basha ◽  
Salman Abdul Moiz ◽  
Mohammed Rizwanullah
Keyword(s):  
Software Development ◽  
Software Design ◽  
Code Generation ◽  
Automatic Code Generation ◽  
Model Based ◽  
Automatic Code ◽  
The Cost ◽  
Software Crisis

One of the goals of software design is to model a system in such a way that it is easily understandable. Nowadays the tendency for software development is changing from manual coding to automatic code generation; it is becoming model-based. This is a response to the software crisis, in which the cost of hardware has decreased and conversely the cost of software development has increased sharply. The methodologies that allowed this change are model-based, thus relieving the human from detailed coding. Still there is a long way to achieve this goal, but work is being done worldwide to achieve this objective. This paper presents the drastic changes related to modeling and important challenging issues and techniques that recur in MBSD.

Practical Considerations in Automatic Code Generation

2011 ◽  
pp. 346-408
Author(s):  
Paul Dietz ◽  
Aswin van den Berg ◽  
Kevin Marth ◽  
Thomas Weigert ◽  
Frank Weil
Keyword(s):  
Code Generation ◽  
High Performance ◽  
Industrial Applications ◽  
Lessons Learned ◽  
Software Systems ◽  
Automatic Code Generation ◽  
Model Driven ◽  
Develop Software ◽  
Stringent Performance ◽  
Automatic Code

Model-driven engineering proposes to develop software systems by first creating an executable model of the system design and then transforming this model into an implementation. This chapter discusses how to automatically transform such design models into product implementations for industrial-strength systems. It provides insights, practical considerations, and lessons learned when developing code generators for applications that must conform to the constraints imposed by real-world, high-performance systems. This deeper understanding of the relevant issues will enable developers of automatic code generation systems to build transformation tools that can be deployed in industrial applications with stringent performance requirements.

scholarly journals A sustainable procedural method of software design process improvements

2021 ◽  
Vol 21 (1) ◽  
pp. 440
Author(s):  
Khalid T. Al-Sarayreh ◽  
Kenza Meridji ◽  
Mamdouh Alenezi ◽  
Mohammed Zarour ◽  
Mohammed D. Al-Majali
Keyword(s):  
Design Process ◽  
Software Design ◽  
Software Process ◽  
Software Systems ◽  
Small Companies ◽  
Design Processes ◽  
Implementation Phase ◽  
Process Improvements ◽  
Different Types ◽  
Procedural Method

In practice, the software process is an intermediate phase for enhancement and improvements the design for different types of software products and help developers to converts the specified requirements into prototypes that implement the design into reality. The objective of this paper is to provide software developers, designers and software engineers who work in small companies with a standards-based process improvement using a procedural method technique including detailed steps for designing the small software systems into their companies. The method used in this paper includes 1) analysis four different types of commonly design processes used by industry such as CMMI, conventional or software process in ISO 19759, generic and engineering design processes. 2)  mapping between those four design processes. 3) collect the dispersed design concepts proposed by those four processes. 4) proposed a sustainable procedural method of software design process improvements 5) Illustration of the applicability of the proposed approach using A template-based implementation. The primary result of this study is<strong> </strong>a guideline procedure with detailed steps for<strong> </strong>software design process improvements to help and guide developers in small companies to analyze and design a small software scales with limited cost and duration. In conclusion<strong>, </strong>this paper proposed a method to improve the design process for different kinds of the software systems<strong> </strong>using<strong> </strong>a template-based implementation to reduce the cost, effort and time needed in the implementation phase<strong> </strong>in small companies. The scientific implication<strong> </strong>behind a template-based implementation helps the system and software engineering to use this template easily in their small companies; because most of the time those engineering developers are responsible for analyzing, designing, implementing and testing their software systems during the whole software life cycle.

Enterprise WAE: A Lightweight UML Extension for the Characterization of the Presentation Tier of Enterprise Applications with MDD-Based Mockup Generation

2017 ◽  
Vol 27 (08) ◽  
pp. 1291-1331
Author(s):  
Humberto Cortés ◽  
Antonio Navarro
Keyword(s):  
Code Generation ◽  
Web Application ◽  
Service Oriented Architecture ◽  
Low Cost ◽  
Unified Modeling Language ◽  
Automatic Generation ◽  
Role Based Access Control ◽  
Enterprise Applications ◽  
Uml Extension ◽  
Automatic Code

Nowadays, the Unified Modeling Language (UML) is the most successful notation for the design of object-oriented applications. However, plain UML is not enough to characterize the web presentation tier of enterprise applications, including the navigational, structural and role-based access control (RBAC) features present in these applications. In this paper, we present Enterprise Web Application Extension (E-WAE), a lightweight UML extension for the modeling of these elements, which permits the inclusion of multitier, Service-Oriented Architecture (SOA) and security design-level patterns in the models. Our approach follows a Model-Driven Development (MDD) approach, which enables the automatic generation of intermediate platform-specific models and automatic code generation for JavaServer Faces (JSF) and Active Server Pages.NET Model-View-Controller (ASP.NET MVC) frameworks. In addition, this generated code can be used as a low-cost mockup for early client validation of the navigational, structural and RBAC features of enterprise applications. E-WAE has been used with different applications. In this paper, we refer to the checkout process in the Amazon website, the delete resources use case in OdAJ2EE, an educational application developed by us, and the US Library of Congress Online Catalog search facility as examples of its applicability.

Rapid Control Prototyping Design of DSP-Based Motion Controller

2011 ◽  
Vol 383-390 ◽  
pp. 308-314
Author(s):  
Lin Li ◽  
Zhi Ming Peng ◽  
Bi Cong Zhang ◽  
Zhang Tie
Keyword(s):  
Code Generation ◽  
Automatic Code Generation ◽  
Motion Controller ◽  
Application System ◽  
Pid Algorithm ◽  
Development Platform ◽  
Development Cycle ◽  
Rapid Control ◽  
Rapid Control Prototyping ◽  
Automatic Code

This paper presents a Rapid Control Prototyping (RCP) development platform based on Matlab/Simulink, Real-Time Workshop and Embedded Target for C2000 and DSP development board. It also designs TMS320F2812 DSP-based motion controller under the proposed RCP. The controller using saturated integral PID algorithm produces PWM signal to control DC motor. Experimental results show that the designed controller can control motor accurately. Engineers can complete all design tasks such as modeling, automatic code generation, and download, running and parameters adjustment on this RCP platform when developing DSP application system. Thus the proposed RCP can shorten the DSP development cycle and improve the portability and modularity of program.

Sign in / Sign up

Export Citation Format

Share Document