Search

Component-based software development (CBSD) is one of the main programming paradigms of the last decades. The main idea of CBSD is to modularize a system as a configuration of multiple interacting components. Components interact with each other via dedicated component interfaces hiding a component's implementation and making components interchangeable. In this paper, we present an early investigation of unit testing practices of open source component-based software systems with the goal to find out how component-based software systems are actually tested and how to improve unit testing practices as part of future research. Our preliminary results show that unit tests typically directly test the component implementation and not dedicated component APIs. The method coverage of component APIs varied between 17% and 34% in the analyzed projects.

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.

Screencasts and videos with screen recordings are becoming an increasingly popular source of information for users to understand and learn about software applications. However, searching for answers to specific questions in screen videos is notoriously difficult due to the effort for locating specific events of interest and reproducing the application's state up to this event. To increase the efficiency when working with screen videos, we propose a solution for replaying recorded sequences shown in videos directly on live applications. In this paper, we describe the analysis of screen videos to automatically identify and extract user interactions and the construction of visual scripts, which are used to run the application in sync with replaying the video. Currently, a first prototype has been developed to demonstrate the technical feasibility of the approach. The paper provides an overview of the implemented solution concept and discusses technical challenges, open issues, as well as future application scenarios.

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.

This paper presents an approach for deriving a state transition model which represents the behavior of a control component using symbolic execution. Symbolic execution is a technique for executing a program using symbolic values for unknowns. It explores execution paths in a program and then uses a SAT/SMT solver to prove that paths are feasible. Further, the approach allows using constraints on the environment and simplifications with a widening operator similar to abstract interpretation.We present the formal foundation of the approach, depict the the tool implementation, present results from a preliminary evaluation, and discuss various application scenarios.

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.

The reuse of code fragments by copying and pasting is widely practiced in software development and results in code clones. Cloning is considered an anti-pattern as it negatively affects program correctness and increases maintenance efforts. Programmable Logic Controller (PLC) software is no exception in the code clone discussion as reuse in development and maintenance is frequently achieved through copy, paste, and modification. Even though the presence of code clones may not necessary be a problem per se, it is important to detect, track and manage clones as the software system evolves. Unfortunately, tool support for clone detection and management is not commonly available for PLC software systems or limited to generic tools with a reduced set of features. In this paper, we investigate code clones in a real-world PLC software system based on IEC 61131-3 Structured Text and C/C++. We extended a widely used tool for clone detection with normalization support. Furthermore, we evaluated the different types and natures of code clones in the studied system and their relevance for refactoring. Results shed light on the applicability and usefulness of clone detection in the context of industrial automation systems and it demonstrates the benefit of adapting detection and management tools for IEC 611313-3 languages., Comment: 8 pages, 2 figures, 2 tables, COMET Center SCCH (FFG #844597), etfa2018

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.

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.

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.

Automated unit tests are an essential software quality assurance measure that is widely used in practice. In many projects, thus, large volumes of test code have co-evolved with the production code throughout development. Like any other code, test code too may contain faults, affecting the effectiveness, reliability and usefulness of the tests. Furthermore, throughout the software system's ongoing development and maintenance phase, the test code too has to be constantly adapted and maintained. To support detecting problems in test code and improving its quality, we implemented 42 static checks for analyzing JUnit tests. These checks encompass best practices for writing unit tests, common issues observed in using xUnit frameworks, and our experiences collected from several years of providing trainings and reviews of test code for industry and in teaching. The checks can be run using the open source analysis tool PMD. In addition to a description of the implemented checks and their rationale, we demonstrate the applicability of using static analysis for test code by analyzing the unit tests of the open source project JFreeChart.

Graphical User Interfaces (GUI) play an essential role in operating industrial facilities and machines. Depending on the range and variability of a manufacturer's product portfolio a huge library of GUI software may exist. This poses quite a challenge when it comes to testing or re-engineering. Static analysis helps to unveil valuable, inherent knowledge and prepare it for further analysis and processing. In our case at ENGEL Austria GmbH, we extract the internal structure of the GUI screens, their variants and the control system context they are used in, i.e. which PLC variables they access. In another step, we analyze the usage pattern of method calls to certain UI widgets. In this paper we show our approach to gain these information based on static analysis of existing GUI source code for injection molding machines.

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.

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.

Technical software systems contain extensive and complex computations that are frequently implemented in an optimized and unstructured way. Computations are, therefore, hard to comprehend from source code. If no other documentation exists, it is a tedious endeavor to understand which input data impact on a particular computation and how a program does achieves a particular result. We apply symbolic execution to automatically extract computations from source code. Symbolic execution makes it possible to identify input and output data, the actual computation as well as constraints of a particular computation, independently of encountered optimizations and unstructured program elements. The proposed technique may be used to improve maintenance and reengineering activities concerning legacy code in scientific and engineering domains.

Software programs in scientific and engineering domains typically contain complex and extensive computations that are additionally optimized concerning running time or memory requirements. As a consequence, the actual computations are often hard to comprehend from the source code only. This paper presents tool support to extract documentation from source code that reveals the actual computation. We discuss how to generate the entire documentation from the source code automatically by using a minimum of additional annotations. This reduces the effort for writing documentation manually and ensures consistency between source code and documentation. Furthermore, the extracted documentation is given in a notation expected and comprehensible by domain experts. We applied our approach in the electrical engineering domain for software systems implemented in the Fortran 90 programming langugage.

In this paper we present an approach and a software prototype that enables domain experts to program control software in the automation domain. The approach follows the principles of domain-specific modeling providing a graphical domain-specific language to model the control cycle of an injection molding machine, a user interface to manipulate and monitor the control cycle as well as code generators to generate control code that can be executed by the machine. As result, domain experts like machine operators can manipulate and monitor the control cycle directly on the touch-screen of a machine without detailed software development expertise.

In this paper we describe our experience from developing and testing a visual graphical user interface (GUI) editor for mobile and multimedia devices. Testing of the editor's highly interactive user interface is critical for its success, yet remains a challenge due to the specification of often intangible quality characteristics of the GUI and its proneness to change. The approach we provide is supporting exploratory testing of the GUI with tools integrated with the tested object. Thus a step-by-step guide for manual exploratory testing can be enhanced with automated elements that directly manipulate the status of the editor, access internal properties of the GUI, and record interactions for bug reporting.

Software testing is essential and takes a large part of resources during software development. This motivates automating software testing as far as possible. Frameworks for automating unit testing are approved and applied for a plethora of programming languages to write tests for small units in the same programming language. Both constraints, unit size and programming language, inhibit automation of software testing in domain of mobile software frameworks. This circumstance has motivated the development of a new testbed for a framework in the domain of mobile systems. In this paper, we describe requirements and challenges in testing mobile software frameworks in general and present a novel testbed for the APOXI framework that addresses these requirements. The main ideas behind this testbed are the usage of a scripting language to specify test cases and to incorporate domain-specific aspects on the language level. The testbed facilitates component and system testing but can be used for unit testing as well.