Orion: A menu-driveri source code generator for end users

Low software development productivity is a major concern for corporations. This paper describes one approach to improve productivity by allowing end users to build their own business data processing systems. The approach uses Orion, a menu-driven software development tool. Orion generates source level COBOL programs that compile and run without modification. The tool does not require end users to know COBOL or high-level query languages. Orion was used for nearly two years to build real business systems. The approach resulted in a significant improvement in software development productivity

Reliability prediction in model driven development

Evaluating the implications of an architecture design early in the software development lifecycle is important in order to reduce costs of development. Reliability is an important concern with regard to the correct delivery of software system service. Recently, the UML Profile for Modeling Quality of Service has defined a set of UML extensions to represent dependability concerns (including reliability) and other non-functional requirements in early stages of the software development lifecycle. Our research has shown that these extensions are not comprehensive enough to support reliability analysis for model-driven software engineering, because the description of reliability characteristics in this profile lacks support for certain dynamic aspects that are essential in modeling reliability. In this work, we define a profile for reliability analysis by extending the UML 2.0 specification to support reliability prediction based on scenario specifications. A UML model specified using the profile is translated to a labelled transition system (LTS), which is used for automated reliability prediction and identification of implied scenarios; the results of this analysis are then fed back to the UML model. The result is a comprehensive framework for addressing software reliability modeling, including analysis and evolution of reliability predictions. We exemplify our approach using the Boiler System used in previous work and demonstrate how reliability analysis results can be integrated into UML models

Amalgamation of Personal Software Process in Software Development Practice

Today, concern for quality has become an international movement. Eventhough most industrial organizations have now adopted modern qualityprinciples, the software community has continued to rely on testing as theprincipal quality management method. Different decades have different trends in software engineering. The Personal Software Process (PSP) is anevolutionary series of personal software engineering techniques that an engineer learns and practices. A software process is nothing without theindividual programmer. PSP a data driven process customized to teaching individuals about their programming styles, helping software engineers  further develop their skills in developing quality software. Apart from  discussing about PSP as a framework of techniques to help engineers and their organizations to improve their performance while simultaneously increasing product quality, in this paper, the Personal Software Process definition, principles, design, advantages and opportunities are explained focusing on the incorporation of PSP concepts in software development practice

The implementation and use of Ada on distributed systems with high reliability requirements

The use and implementation of Ada were investigated in distributed environments in which reliability is the primary concern. In particular, the focus was on the possibility that a distributed system may be programmed entirely in Ada so that the individual tasks of the system are unconcerned with which processors are being executed, and that failures may occur in the software and underlying hardware. A secondary interest is in the performance of Ada systems and how that performance can be gauged reliably. Primary activities included: analysis of the original approach to recovery in distributed Ada programs using the Advanced Transport Operating System (ATOPS) example; review and assessment of the original approach which was found to be capable of improvement; development of a refined approach to recovery that was applied to the ATOPS example; and design and development of a performance assessment scheme for Ada programs based on a flexible user-driven benchmarking system

Guest Editorial to the Theme Section on Model-Driven Web Engineering

Model-Driven Engineering (MDE) is becoming a widely accepted paradigm for the design and development of complex distributed applications. MDE advocates the use of models and model transformations as key artefacts in all phases of the software process, from system specification and analysis, to design, development and testing. Each model usually addresses one concern, independently from the rest of the issues involved in the construction of the system. Thus, the basic functionality of the system can be separated from its final implementation, and the business logic can be separated from the underlying platform technology, etc. Transformations between models enable the automated implementation of a system from the different models defined for it.Facultad de Informátic

The Impact of Organizational Culture and Structure on the Routinization of Agile Software Development Methodologies

Agile software development methodologies represent a departure from the heavy document-driven procedures of plan-driven approaches. As organizations continue to adopt agile methodologies, understanding the factors that influence the routinization of agile is a growing concern. In recent years, researchers have focused their attention to the issues of post-adoptive agile use in order to extend our knowledge on agile assimilation. However, little research has been conducted to expose the assimilation gaps that occur as organizations seek to increase the extent and intensity of their agile use. Following prior literature, our objective is to articulate a model that explains the impact of organizational culture and structure on the routinization of agile methods. Our theoretical model provides helpful insights that extend our of knowledge of agile assimilation in organizations

Model interoperability via model driven development

It is widely recognised that software development is a complex process. Among the factors that contribute to its inherent complexity is the gap between the design and the formal analysis domains. Software design is often considered a human oriented task while the analysis phase draws on formal representation and mathematical foundations. An example of this dichotomy is the use of UML for the software design phase and Petri Nets for the analysis; a separation of concerns that leads to the creation of heterogeneous models. Although UML is widely accepted as a language that can be used to model the structural and behavioural aspects of a system, its lack of mathematical foundations is seen as a serious impediment to rigorous analysis. Petri Nets on the other hand have a strong mathematical basis that is well suited for formal analysis; they lack however the appeal and the easeof-use of UML. A pressing concern for software developers is how to bridge the gap between these domains and allow for model interoperability and the integration of different toolsets across them, and thus reduce the complexity of the software development process. The aim of this paper is to present a Model Driven Development (MDD) model transformation which supports a seamless transition between UML and Petri Nets. This is achieved by model interoperability between UML Sequenc

Assistance in Model Driven Development: Toward an Automated Transformation Design Process

Model driven engineering aims to shorten the development cycle by focusing on abstractions and partially automating code generation. We long lived in the myth of automatic Model Driven Development (MDD) with promising approaches, techniques, and tools. Describing models should be a main concern in software development as well as model verification and model transformation to get running applications from high level models. We revisit the subject of MDD through the prism of experimentation and open mindness. In this article, we explore assistance for the stepwise transition from the model to the code to reduce the time between the analysis model and implementation. The current state of practice requires methods and tools. We provide a general process and detailed transformation specifications where reverse-engineering may play its part. We advocate a model transformation approach in which transformations remain simple, the complexity lies in the process of transformation that is adaptable and configurable. We demonstrate the usefulness, and scalability of our proposed MDD process by conducting experiments. We conduct experiments within a simple case study in software automation systems. It is both representative and scalable. The models are written in UML; the transformations are implemented mainly using ATL, and the programs are deployed on Android and Lego EV3. Last we report the lessons learned from experimentation for future community work