Software development is program transformation

The paper proposes a unified formal model driven approach to software evolution based on both program transformation and model transformation of legacy systems. A formal model definition ensures a consistent interpretation of the legacy system and provides a theoretical foundation for dependable software evolution. The theoretical foundation is based on the construction of a wide spectrum language for reengineering, known as WSL, which enjoys a sound formal semantics. The architecture and working flow of the approach are proposed, and the mappings between WSL and PSL in MDA provide an engaging combination of traditional program transformation and modern model transformation, which shows that the proposed approach is feasible and promising in its domain. A prototype tool is developed to test the approach and a case study is used for experiments with the proposed approach and the prototype tool. Conclusion is drawn based on analysis and further research directions are also discussed

Software evolution demands continuous adaptation of software systems to continuously changing requirements. Our goal is to cope with software evolution by automating program transformation and system reconfiguration. We show that this can be achieved with a static metaprogramming facility and a library of suitable metaprograms. We show that former approaches of program transformations are not sufficient for large object oriented systems and outline two base transformations that fill the gap.

A primary benefit of most software tools is either the prevention or the detection of human error in the development process. Languages, such as Pascal and Ada, have been designed with features such as strong typing to increase the amount of error detection that can be done by the compiler. Syntax directed editors [11] also decrease the opportunity for the introduction of human error.Our paper describes some of the debugging assistance which can be provided to a user during the transformation of a program by an optimizing compiler. Our premise is that the additional information obtained during optimization could warrant the sole use of optimizing compilers during software development.

Model transformations are frequently used means for automating software development in various domains to improve quality and reduce production costs. Debugging of model transformations often necessitates identifying parts of the transformation program and the transformed models that have causal dependence on a selected statement. In traditional programming environments, program slicing techniques are widely used to calculate control and data dependencies between the statements of the program. Here we introduce program slicing for model transformations where the main challenge is to simultaneously assess data and control dependencies over the transformation program and the underlying models of the transformation. In this paper, we present a dynamic backward slicing approach for both model transformation programs and their transformed models based on automatically generated execution trace models of transformations.

Software systems need constantly maintaining or adapting to continuously meet the changing business requirements. The process of maintenance or adaptation is software evolution. In general, people hope to evaluate software evolution for guiding software maintenances. By evaluating how well software maintenances follow the positive evolutionary trends, developers can assert whether it is necessary to redevelop or even refactor newly released or maintained versions of software to enforce the software evolution back on track. In this paper, we propose an approach to evaluating software evolution based on API usage patterns, which are the accumulations and summarizations of people's software design and development experience. In the approach, better software evolution is considered as the process of reusing more usage patterns, and software evolution is evaluated based on how well software reuses usage patterns in the process of evolution. Our work consists of three parts. First, we use a graph-based algorithm to mine usage patterns from different open-source software. Second, we use the patterns to evaluate the evolutions of software systems and accordingly analyze the important changes during software evolution. Third, we compare different approaches and analyze which approach can reflect the process of software evolution accurately. Our experiments on several open source programs show that our approach is more effective than other approaches on identifying the great change events during software evolution.

Experimentally assessing the combination of multiple visualization strategies for software evolution analysis

Model transformation is seen as a promising approach to automate software development and verification, thus improving quality and reducing production costs significantly. However, errors of transformation programs can propagate into the generated artifacts complicating the detection of errors. The current paper proposes a static type checking approach for early detection of typing errors of partially typed transformation programs. The approach describes type safety as constraint satisfaction problems, and uses a dedicated back-annotation mechanism for error feedback.

Comparing functionality of software systems: An ontological approach

This paper discusses results obtained during a research project aimed at developing an e-learning platform for university courses, called Intelligent Web Teacher (IWT). Most studies of this kind are based on expert assessment, either software developers or competent users; in this research we analyzed students’ point of view through qualitative data. In particular, three thinking aloud protocols were collected during a study session at the university lab. Four university students (two of them worked in dyad and produced one protocol), from 19 to 23 years old, volunteered to be trained for thinking aloud sessions while using the platform. Discourse analysis is used to discern how meaning was organized in the three protocols and to discover what topics emerged during use of the e-learning platform (Sacks, 1992; Schegloff, 1992). Based on the gathered list of topics, a set of recommendations useful to both software developers and educators is outlined. Finally, it is suggested how to promote an active e-learner profile in place of the passive profi le that emerges.

This work presents the development of the software that controls a set of equipments, called Ground Support Equipment (GSE), which verifies requirement fulfilling and helps integration procedures of the CBERS-3 and 4 satellites’ Multispectral Camera (MUXCAM). The software development followed an iterative spiral model, with agile methods characteristics that were originally used at Opto Electronics in industrial and medical equipment’s projects. This approach allowed a small team, constituted by only four engineers, to fast create the first software version, even sharing time with GSE’s hardware development, and to keep the project on schedule, in spite of some requirement changes.

E-commerce and e-government depend on trustworthy software platforms. Unfortunately, barely a week goes by without the discovery of a "critical" software vulnerability that would give a remote party complete access to a large number of network-attached computers. Considering the rising financial incentives and the immeasurable strategic importance of such vulnerabilities, one should assume that there are parties within commercial software companies that are actively scouting out (and perhaps even inserting) such errors for future exploitation. For various reasons that we touch on briefly, software manufacturers appear to be unwilling to even discuss this possibility. We explain why open-source software development is not a solution, either. We then outline an approach that significantly reduces the problem, even when malicious insiders are part of the software development team. Our approach is based on running several slightly different versions of the same software in parallel on different cores of a multiprocessor. As a beneficial side effect, our method is able to locate actual programming errors.

Software is not perfect and may contain bugs that cannot be detected by tests, or that will manifest themselves only over time. Sometimes problems can occur even in the code of third-party libraries or services that are used in the software system. To improve the reliability of software systems and timely detection of problems, data logging is used. Logging is a very important aspect of software development. By studying application logs, software developers can detect anomalies and errors in software systems, find the cause and provide an update or patch with fixes. Nevertheless, despite the importance of data logging practice, in most cases this process is chaotic. Developers write logging code solely based on their own considerations or neglect it altogether. This study points to the need to improve the state of research on data logging practices. For example, more efforts should be made to define what exactly to log, to generate logging data in a clear way and from the developer’s point of view with enough information to recreate the events even without having to run the application. This article describes ways in which this can be achieved. This research aims to establish a comprehensive understanding of the state of the art in data logging research with an emphasis on identifying possible problems and gaps that will further shed light on potential future research directions. This paper describes a study that focused on logging strategies used on real projects of different types. It investigated logging methods for desktop and web applications, and proposed improvements to the logging methodology that make it more flexible and convenient for software development teams regardless of the types of applications being developed.

DOD-STD-2167A, the US Department of Defense Defense System Software Development standard, establishes requirements to be applied not only to software development but also to the support of software systems. The authors present a tailored 2167A process as the procedural philosophy for a defense industry software support group. Even though the software being maintained was not developed under the 1267A process, use of 2167A as a guideline in maintenance provides a better product than prior maintenance procedures. The tailored process includes nested software development cycles that address annual software version releases at the highest level, aggregates of software problem reports (SPRs) at the intermediate level, and individual SPRs at the lowest level. The complete process is described at each level.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Change is the heart of software development. As new platforms appear, some batch systems have been retrofitted with first a web interface, then a web service interface, and now interfaces to mobile devices. Unfortunately, programmers perform most software changes manually, through low-level text edits, which are almost never reused. This makes software development time-consuming, error-prone, and expensive. It is widely known that at least two thirds of software costs are due to evolution, with some industrial surveys claiming 90%.

In a training process for DSP software developers' major schools and scientific societies see an actual problem for a kind of transformation from a traditional form of training into different remote forms, using one-to-many online training courses and interactive case study. We have analyzed many different examples of such a new forms of trainings that have been used or trialed by major technical universities. Within our analysis we have defined requirements for automatic training system (ATS) for a developers of DSP software. The major goal for specified ATS should be a possibility for any trainee to get a knowledge and skills in a practical stand-alone way, with near zero interaction with anyone else except ATS. Basic scenarios, short tests allows trainee not only get soft-start and to achieve fast wins, but also motivate him for a professional development and deeply involve him into process of SDP software development. Comparing to widely and massively used courses covering basic tasks and general questions of DSP software development, proposed ATS is more specialized and requires higher level of entry qualification for trainee. From practical point of view we suppose to include game-approach and real-time interaction with trainee during whole process of ATS. This leads to a problem of real-time computation and real-time automating for a trainees solution check and giving a relevant feedback in a way of showing radio signal in a logical visual way both for source and processed signals. This allows forming right understanding not only for SDP software development skills but also understanding of major functional principles of complex radio systems. For example, for DSP ECC decoding we are using visualized encoded and decoded signals, and for spectrum processing tasks we are using visualized spectrum areas. Another interesting approach is to use the best solutions done by trainees to include them into a kind of knowledge library for further use. Today we have implemented proposed approach onto SW being deployed and used during courses of DSP software development from year of 2016. We see first outcome of usage this ATS.