A Low-Code Development Platform (LCDP) enables people with little or no software development training to create software applications. Unlike traditional textual programming environments, it provides tools that are more natural to the users, such as visual programming. By raising the level of abstraction beyond code, an LCDP empowers those who need software to develop it, bridging the gap between the growing demand for industrial software and the ability to deliver it. In this paper, we present an iterative, user-centered approach for developing an LCDP for welding robot control that replaces a system based on the C programming language. Findings indicate that an iterative approach, active user participation, usability evaluations, and paper prototyping all favor the successful development of an industrial LCDP.

The evolution and re-engineering of software is strongly supported by comprehensive test suites for checking the correctness and robustness of software systems. However, this requires comprehensive test suites to be in place or developed prior to re-engineering of systems. Many techniques and strategies have been proposed to automate the creation of test suites. Specification-based testing aims to use all available behavioral specifications of software to drive black-box testing of software. In this paper, we present an approach, which applies specification-based testing to component software in the engineering domain, supporting an ongoing re-engineering process aiming to transform monolithic C++ engineering software into reusable fine-grained computational services. The developed test generator (TxTea) uses source code annotations added to component interface definitions and drives test data generation by a randomized testing approach, which integrates a satisfiability modulo theories (SMT) solver to check satisfiability and generate test data for comprehensive preconditions. As we show, TxTea can be successfully applied to a given component technology, and as we discuss in this paper, the customized specification language and generic implementation make reuse in more general use cases feasible.

Accurate and up-to-date software documentation is an important factor in the maintenance and evolution of software systems. Especially with legacy software, documentation is often outdated or missing entirely and manual redocumentation is not feasible. In recent years, automatic code summaries based on artificial neural network (ANN) models have been proposed to address this problem, and metric-based evaluations suggest promising quality of the generated summaries. To evaluate the applicability of state-of-the-art code summarization in an industry context, we conduct an expert evaluation to assess the quality of the generated summaries for JPA program comprehension. We then compare the level of quality perceived by human experts for both predicted and reference summaries and discuss how these results are influenced by industry-specific requirements and how they correlate with automatically computed source code summary metrics. The results show that the quality of predicted summaries is predominantly (about 80%) poor in terms of accuracy and completeness. Moreover, the results support the generally increasing consensus that the widely used BLEU or ROUGE-L score is not a suitable means of evaluating the quality of code summarization. While these metrics are an adequate means of comparison with existing related work, they cannot reflect the human-perceived level of quality in practice.

The specification of program inputs is a requirement for many software engineering tasks, but often does not exist or is out of date. To tackle this problem, software engineers may apply program analysis techniques to extract parts of a specification from the source code that processes the program input. Today there are analysis techniques for the extraction of constraints (mathematical formulas) for individual program inputs (e.g. function parameters) as well as emerging techniques for inferring context-free grammars that specify the syntax of program input strings. However, such techniques focus on a single aspect (e.g., constraints or grammars) of the specification only and neglect the other one. We propose to integrate such analysis techniques by extending existing approaches for mining input grammars with the extraction of constraints. Constraints are integrated with a grammar in the form of attributes and context constraints on grammar symbols, resulting in an attribute grammar as specification format. To achieve this goal, we choose the analysis method dynamic symbolic execution (DSE), which is already an established technique for the extraction of constraints and beneficial for grammar mining (e.g., through automatic input generation) as well. Thus, DSE not only covers both aspects but also—as a single analysis method—should facilitate the integration of these two aspects. In this paper, we describe the basic idea of the proposed integration and report the first results on DSE-based grammar extraction.

Software documentation is an asset for many activities in maintenance and evolution of software. To alleviate the problem of outdated or lost documentation and to improve program understanding, reverse engineering tools and documentation generators have been developed and used during development, maintenance, and evolution of software systems. In this paper, we report on the development of six tools that address different programming languages (e.g. COBOL, Java, and C), problem domains (e.g. banking, insurance, and engineering), and SE activities (e.g. maintenance and migration). While the development of these tools was driven by domain-specific requirements, an architecture that supports reuse of components for the analysis and visualization of software from different programming languages was pursued from the beginning. This resulted in a polyglot software platform for building reverse engineering tools and documentation generators. The software platform provides a modular set of programming language frontends, static program analysis components and document/diagram generators. To evaluate effectiveness of the platform for tool creation, we conducted an industrial case study and discuss results on reuse potential, adoption of new languages and usage of a generic intermediate representation.

Abstract Source code comments contain key information about the underlying software system. Many redocumentation approaches, however, cannot exploit this valuable source of information. This is mainly due to the fact that not all comments have the same goals and target audience and can therefore only be used selectively for redocumentation. Performing a required classification manually, for example, in the form of heuristics, is usually time‐consuming and error‐prone and strongly dependent on programming languages and guidelines of concrete software systems. By leveraging machine learning (ML), it should be possible to classify comments and thus transfer valuable information from the source code into documentation with less effort but the same quality. We applied classical ML techniques but also deep learning (DL) approaches to legacy systems by transferring source code comments into meaningful representations using, for example, word embeddings but also novel approaches using quick response codes or a special character‐to‐image encoding. The results were compared with industry‐strength heuristic classification. As a result, we found that ML outperforms the heuristics in number of errors and less effort, that is, we finally achieve an accuracy of more than 95% for an image‐based DL network and even over 96% for a traditional approach using a random forest classifier.

Source code comments contain key information about the underlying software system. Many redocumentation approaches, however, cannot exploit this valuable source of information. This is mainly due to the fact that not all comments have the same goals and target audience and can therefore only be used selectively for redocumentation. Performing a required classification manually, e.g. in the form of heuristic rules, is usually time-consuming and error-prone and strongly dependent on programming languages and guidelines of concrete software systems. By leveraging machine learning, it should be possible to classify comments and thus transfer valuable information from the source code into documentation with less effort but the same quality. We applied different machine learning techniques to a COBOL legacy system and compared the results with industry-strength heuristic classification. As a result, we found that machine learning outperforms the heuristics in number of errors and less effort.

This paper presents an extension to TrueTime, a widely used toolbox for co-simulation of networked real-time control systems in the block-oriented modeling and simulation environment MATLAB/Simulink. TrueTime provides an implementation of a real-time kernel as a Simulink block, which is able to execute a set of tasks and interrupt handlers under various scheduling schemes. By annotating the controller code with platform-specific timing information, it thereby allows to observe the temporal behavior and scheduling effects arising from the actual controller implementation in closed loop with the plant. This goes beyond traditional development approaches within the synchronous (reactive) block-diagram formalism of Simulink, which typically ignores execution times and jitter. However, TrueTime is said not to be suited for industrial (legacy) applications, mainly due to its structural requirements on the controller code. We propose an alternative execution mechanism that overcomes this limitation and fits with typical controller code as, for example, generated by the Simulink/Embedded Coder. Optionally, tasks may have individual execution stacks and may also execute as individual threads, even allowing for accelerated simulation on multi-core simulation hosts. Furthermore, this introduces support for instruction level timing and deeply branched function call graphs, without distorting the code structure. A case study demonstrates the applicability of our approach.

Model-driven software development comes in different styles. While standard-based approaches leverage existing language standards (e.g. UML), tooling, and even development processes, DSM requires domain-specific languages and tool support to be created prior the actual software development. The design, implementation, and test of languages and tool support require a wide spectrum of methods and techniques where each of it brings also additional complexity and challenges. To tackle these DSM-specific challenges, best practices have been collected from various application domains and published in literature to guide the development and application of DSM solutions. This work explores existing best practices by conducting a systematic mapping study. We identify and classify studies reporting practical guidance on domain-specific modeling and present best practices from literature. Moreover, we discuss how best practices overlap, complement, or contradict each other. From a total of 309 best practices in 19 papers, we compiled 191 unique best practices. The systematic and comprehensive compilation of best practices is intended to facilitate industrial adoption of DSM in various domains.

Human Machine Interfaces (HMI) play a pivotal role in operating industrial machines. Depending on the extension of a manufacturers domain and the range of its machines as well as the possible options and variants, the ensuing HMI component repository may become substantially large, resulting in significant maintenance requirements and subsequent cost. A combination of cost pressure and other factors, such as significant change of requirements, may then call for a substantial reengineering. A viable alternative to manually reengineering the whole HMI framework might be the use of (semi)-automated reengineering techniques for suitable parts. We describe such a model based reengineering procedure relying on static analysis of the existing source code for suited aspects of a large HMI framework. We will sketch our overall approach including the objectives and highlight some important challenges of transforming HMI component information extracted from source code into a representation developed for the completely redesigned HMI infrastructure in the light of an existing product assembly and configuration process at a large machinery manufacturer.

Complex engineering problems are typically solved by running a batch of software programs. Data exchange between these software programs is frequently based on semi-structured text files. These files are edited by text editors providing basic input support, however without proper input validation prior program execution. Consequently, even minor lexical or syntactic errors cause software programs to stop without delivering a result. To tackle these problems a more specific editor support, which is aware of language concepts of data exchange files, needs to be provided. In this paper, we investigate if and in what quality a language grammar can be inferred from a set of existing text files, in order to provide a basis for the desired editing support. For this experiment, we chose a Minimal Adequate Teacher (MAT) method together with specific preprocessing of the existing text files. Thereby, we were able to construct complete grammar rules for most of the language constructs found in a corpus of semi-structured text files. The inferred grammar, however, requires refactoring towards a suitable and maintainable basis for the desired editor support.

Software migration projects need precise and up-to-date documentation of the software system to be migrated. Missing or outdated documentation hampers the migration process and compromises the overall quality of the resulting new software system. Moreover, if documentation is missing in the first place and no additional effort is undertaken to document the new software system, future maintenance and evolution tasks are burdened right from the beginning. Therefore, we apply an automatic re-documentation approach that uses a single tool chain to generate documentation for the software to be migrated and the transformed software system. By this, we not only support an ongoing COBOL to Java migration project at one of our industry partners but as well create the foundations to continuously generate up-to-date documentation for the new software system.

We describe the motivation, approach and first experience from reverse engineering Common Intermediate Language (CIL) for the purpose of documentation generation. Instead of parsing source code implemented in different programming languages, we reverse engineer CIL code and thereby enable documentation generation for all programming languages that can be compiled into CIL code. Initial results show that we are able to generate documents in the same quality as compared to directly analyzing source code. To overcome initial shortcomings we introduce additional preprocessing in form of AST refactoring which is not required when analyzing source code.

In software development we are faced with the problem to comprehend and take over source code from other developers. The key challenge is to understand the underlying specification implemented by the software system. Regaining this understanding is more difficult when the source code is the only reliable source of information, documentation is outdated or only present in fragments, and original developers are not available anymore. Unfortunately, we encounter such situations frequently for scientific and engineering software systems, developed in industry. For instance, process models in the steelmaking domain are developed and maintained over decades by single engineers. If such an engineer leaves the company, he/she literally leaves behind a legacy system for another person (or team). We propose tool support combining static and dynamic program analysis to tackle this challenge. Using static program analysis we extract the input/output behavior from program source code and present the extracted information besides the analyzed source code, providing seamless navigation between both views. Dynamic program analysis allows developers to examine input/output behavior for single program executions and thereby gain insight into standard behavior and exceptional cases. In this paper we present requirements on tool support integrating static and dynamic code analysis, briefly describe the implementation of the tool and report on its application to a C++ program source in the industry. Furthermore, we discuss challenges in the present implementation as well as the potential and limitations of using the tool in general.

Reverse engineering tools are utilized for development, maintenance, and modernization of software systems. The reverse engineering community has developed a large number of reverse engineering tools for different programming languages that support a variety of software engineering activities. Although tools address different reverse engineering problems and different programming languages, several issues with respect to parsing, intermediate representations, code query, program analysis, etc. are similar. However, reuse between tools takes place only on a moderate scale. To facilitate reuse in building reverse engineering tools, we have used the OMG standard ASTM as intermediate representation of source code together with black box reuse of existing (free) language parsers. In this paper we report on challenges, experiences, and solutions from several industrial research projects, in which ASTM based reverse engineering tools have been developed and used for re-documentation, re-engineering, and modernization of software systems.

This paper demonstrates RbG, a new tool intended for the generation of high-quality documentation from source code of scientific and engineering applications. RbG extracts mathematical formulae and decision tables from program statements by means of static code analysis and generates corresponding documentation in the Open Document Format or LaTeX. Annotations in source code comments are used to define the structure of the generated documents, include additional textual and graphical descriptions, and control extraction of formulae on a fine-grained level. Furthermore, RbG provides an interpreter to generate function plots for extracted formulae. In this tool demonstration we briefly introduce the tool and show its usage for different scenarios such as reverse engineering and re-documentation of legacy code and documentation generation during development and maintenance of software.

The interface between human operators and industrial control systems (HMI, Human Machine Interface) is a key component for operating and configuring industrial machines and facilities, which have grown in terms of functionality and complexity. However, HMI software in industrial operation tends to have a longer lifespan than desktop or office software. Besides growing maintenance cost over time, it might also happen that the capability or lifecycle of the base technologies render the adaption to new requirements extremely difficult if not impossible. Quite frequently, HMI software targeting a specific application domain is then completely rebuilt from scratch on the base of a new or heavily altered base technology. In our work, we support the reengineering of HMIs by static analysis of its source code and the extraction of key information to an implementation technology independent model. In a subsequent step these models shall be the starting point to generate at least parts of the HMI based on a new technology. This paper describes the motivation, requirements and challenges that inhere in this task. In addition, we provide a short insight into first findings based on the analysis of a real world HMI source code from the domain of injection moulding.

Implementation, fault analysis, and maintenance of robot welding automation solutions are traditionally restricted to professional software developers only. Program code is written in a general purpose programming language and, hence, unmanageable by other stakeholders with limited or no programming skills. To tackle this problem we have implemented a domain-specific language (DSL) specifically designed to the domain of robot welding automation and to be intuitively manageable by all stakeholders. The created DSL supports a textual and visual notation and is embedded within a full featured tool chain which let our customer fully replace the creation and maintenance of welding automation solutions by our DSL-based development approach.

The reengineering of legacy code is a tedious endeavor. Automatic transformation of legacy code from an old technology to a new one preserves potential problems in legacy code with respect to obsolete, changed, and new business cases. On the other hand, manual analysis of legacy code without assistance of original developers is time consuming and error-prone. For the purpose of reengineering PL/SQL legacy code in the steel making domain, we developed tool support for the reverse engineering of PL/SQL code into a more abstract and comprehensive representation. This representation then serves as input for stakeholders to manually analyze legacy code, to identify obsolete and missing business cases, and, finally, to support the re-implementation of a new system. In this paper we briefly introduce the tool and present results of reverse engineering PL/SQL legacy code in the steel making domain. We show how stakeholders are supported in analyzing legacy code by means of general-purpose analysis techniques combined with domain-specific representations and conclude with some of the lessons learned.

Associating business information with information about IT resources is important. Organizations need to understand the business relevance of resources to answer questions such as which business applications are affected in case of a server outage, and to understand the resource footprint of business applications. Maintaining this relationship over the life cycles of resources and business applications is difficult because data on business applications and IT configuration information are maintained very differently. Business application information is maintained by employees in the course of a management process, whereas IT configuration information can be maintained more vigorously by scanning IT resources and storing the results in a Configuration Management Database (CMDB), where this actual configuration information can be reconciled with an authorized configuration. This paper proposes an approach to associate business application information with configuration information by “watermarking” IT resources with references to information on the business purpose they serve. This enables the establishment of a relationship between automatically detected and manually managed information in a consistent, reliable, and cost-effective way as well as the identification of inconsistencies that may develop over time.

The impact of model-based design on the software engineering community is impressive, and recent research in model transformations, and elegant behavioral specifications of systems has the potential to revolutionize the way in which systems are designed. Such techniques aim to raise the level of abstraction at which systems are specified, to remove the burden of producing application-specific programs with general-purpose programming. For complex real-time systems, however, the impact of model-driven approaches is not nearly so widespread. In this paper, we present a perspective of model-based design researchers who joined with software experts in robotics to enter the DARPA Urban Challenge, and to what extent model-based design techniques were used. Further, we speculate on why, according to our experience and the testimonies of many teams, the full promises of model-based design were not widely realized for the competition. Finally, we present some thoughts for the future of model-based design in complex systems such as these, and what advancements in modeling are needed to motivate small-scale projects to use model-based design in these domains.

In the typical Web application, a client renders markup and the application or service is implemented as a set of tiered functions in the network. However, clients can contain resources useful for an application and network connections cannot always be assumed. In this paper, we consider extending the reach of a Web application to include: 1) access to and use of local client resources, and 2) operation while disconnected from the network. We, however, try to preserve desirable programming model and management characteristics of Web applications. We propose a system architecture and discuss an initial implementation using a portal as an example Web application.

The DEAPspace project is building an interaction framework for connecting pervasive devices over the wireless medium, supporting the development of new proximity-based collective distributed applications. The main components of this framework are the discovery algorithm and the service description model. DEAPspace provides devices with useful information about the other devices in their surroundings. This information can be queried in a consistent way that will tolerate evolutions, and allow legacy devices to continue to function in the fast-developing world of pervasive gadgets. The discovery is done in a power-efficient, and network-friendly way, and will adapt to a wide range of error conditions. This framework has been implemented, and allows the development of distributed applications that use ad-hoc transient networking as part of their function. The primary implementation was in Java. A subset of the code was also written in C, to allow the use of machines which do not have a JVM. In addition to simulation, the code has been tested over TCP/IP and the Ethernet interface of an 802.11 link.

An integrated programming environment for the M/sup 3/ multiprocessor is discussed. Three tools support the software development cycle of a parallel program, including the programming, configuration, and debugging/performance measurement phases. Programmer support for performance analysis has been a primary motivation for the system. The sources of performance loss are identified and the ways in which this information is gathered and analyzed are described. As a case study, a fast maze router algorithm is used to show the functionality of the different tools. The M/sup 3/ environment is compared with other state-of-the-art projects.>