Refactoring large legacy codebases, even with industrial-strength tools, often leads to trust concerns with code owners, in particular when the codebase underwent significant changes. To provide more assurance to code owners, we integrate visual analytics into the refactoring process. This method involves transforming code into control flow graphs before and after refactoring, followed by trace equivalence analysis on these graphs. An innovative visualisation tool provides not only a comprehensive overview of the refactorings' impact across all files, but also offers detailed insights into the trace equivalence at individual file level. By presenting clear visual evidence of code equivalence before and after refactoring, our visualisation narrows the trust gap, offering refactoring experts and code owners a transparent and understandable view of the changes. We apply this visualisation on an industrial use case and discuss its effectiveness with refactoring experts.

We propose a tool and underlying technique that uses semi-parsing to extract control flow graphs from legacy source code (i.e., COBOL). Obtaining such control flow graphs is relevant in the industrial setting of legacy modernisation, to quickly demonstrate to code owners that modernisation engineers did not break their business logic. They need to be convinced that a migration did not affect the flow around critical parts of their code such as database accesses. Focusing on the control flow around embedded SQL queries and confirming that the code logic has been preserved improves customers' trust and satisfaction in the modernisation. Our proposed algorithm and approach uses fuzzy parsing as opposed to full parsing to parse mainly the control flow constructs, while delegating the full parsing of embedded languages like SQL to an external parser, and produces a control flow graph directly while skipping over most of the input in linear time. Such a fuzzy parser is easier to construct and adapt to particular languages and needs than a full parser with a visitor to elicit control flow. Comparisons are made of the fuzzy parser to an industrial-strength full parser.

In automated compiler testing, the focus typically lies in uncovering bugs caused by optimisations performed by the compiler. However, there is a class of compilers where little to no optimisations are performed: those for migration of legacy software. Therefore, it is not clear to what extent such legacy compilers would benefit from automated compiler testing. We investigated this in the context of the Raincode legacy compiler for PL/I, an industrial compiler targeting the. NET platform. We designed and implemented a framework for automated PL/I compiler testing through precomputation-based program generation and ran it on two versions of the Raincode PL/I compiler: an older with known bugs and the latest release. On the older version, our framework generated around 127.000 programs and found five bugs, two of which were previously unknown to us. For the latest compiler release, after 180 hours of tests and more than 718.000 generated programs, the framework did not reveal any bugs.

Large code refactoring projects can consist of hundreds of refactoring rules that are applied iteratively to make code easier to maintain. Visualising the refactoring process can help engineers and stakeholders understand how chains of refactorings were applied and to gain more confidence in the produced result. An apparently suitable existing visualisation using log-based behavioural differencing suffers from scalability issues when applied to industrial-size cases. We propose an adapted visualisation tool that highlights those parts that really changed in-between iterations of a large refactoring process and collapses those parts that remain stable. We show that our alternative visualisation scales well on large logs of a process with many possible refactoring chains, of which significant parts are shared. Consequently, it allows engineers and stakeholders to quickly answer relevant questions about what happened during the refactoring process.

When migrating legacy systems to more contemporary platforms, it is not always feasible to migrate their external library dependencies as well. A workaround can be to partially reimplement the library dependencies on the new platform, limiting oneself to the features that are used by the migrated system. For contemporary programming languages, several approaches to mining for library usage patterns have been proposed. For legacy programming languages, in contrast, such tools are lacking. This encumbers establishing what parts of a library need to be rewritten during a migration project, especially when considering large-scale systems.In this industry track paper, we present an approach to mining library usage patterns in COBOL code. We describe a library usage extractor for COBOL, which produces graphs that capture the control and data flow involved in library calls. The extractor supports legacy control flow features, such as GO TO. We use these graphs as input to two state-of-the-art frequent subgraph mining algorithms, and report on the scalability of their use for mining common library usage patterns in two industrial COBOL systems. The mined library usage patterns can help assess and subsequently steer the migration effort.

Part of the ecosystem of applications running on mainframe computers is the DFSORT program. It is responsible for sorting and reformatting data (amongst other functionalities) and is configured by specifications written in a Domain-Specific Language (DSL). When migrating such sort workloads off from the mainframe, the SyncSort product is an attractive alternative. It is also configured by specifications written in a DSL but this language is structured in a radically different way. Whereas the DFSORT DSL uses an explicit fixed pipeline for processing, the SyncSort DSL does not. To allow DFSORT workloads to run on SyncSort we have therefore built a source-to-source translator from the DFSORT DSL to the SyncSort DSL. Our language converter performs abstract interpretation of the DFSORT specification, considering the different steps in the DFSORT pipeline at translation time. This is done by building a graph of objects and key to the construction of this graph is the reification of the records being sorted. In this paper we report on the design and implementation of the converter, describing how it treats the DFSORT pipeline. We also show how its design allowed for the straightforward implementation of unexpected changes in requirements for the generated output.

Typically in modernisation projects any concerns for code quality are silenced until the end of the migration, to simplify an already complex process. Yet, we claim from experience that prioritising quality above many other issues has many benefits. In this experience report, we discuss a modernisation project of mBank, a big Polish bank, where bad smell detection and elimination, automated testing and refactoring played a crucial rule, provided pay-offs early in the project, increased buy-in, and ensured maintainability of the end result.

It is our pleasure to present this special edition of the Journal of Software: Evolution and Process for the 4th IEEE Working Conference on Software Visualization (VISSOFT 20016). The technical program of the conference featured 9 full papers selected out of a total of 21 submissions, and of these 9 we invited 4 to submit an extended version to this special issue. Our thanks go to the authors for extending their work with additional interesting material, and to the reviewers for their review effort and the invaluable comments that resulted.

Physics engines in robotics simulators should yield a simulation that is physically faithful to the real world. However, simple scenarios like dropping a ball on the floor already reveal that this is not so. There is hence a need to be able to test such engines in real world scenarios, to see where they are lacking. To help to quickly and efficiently develop unit tests for real-world behavior we developed a tool we call Live Tests for Robotics. In this tool paper we show how its interactive visualizations allow for the efficient construction of such unit tests.

In a robotics context, visualizing the data scanned by a robot is crucial to understand what the robot's sensors perceive about its environment. Consequently, robotic visualizations show these values in a 3-D world, such that they can be compared with the real world. However these visualizations do not allow developers to see this data in a manner that allows it to be interpreted for program construction. As a result, these visualizations are in many cases ineffective for programming robot behaviors. To address this issue, we have built several visualizations of robot sensor data for the programming of behaviors, and we report on them here. Our visualizations focus on better revealing the hard data, which allows developers to faster understand it and consequently to faster create and adapt robot behaviors.

Gradual typing combines static and dynamic typing flexibly and safely in a single programming language. To do so, gradually typed languages implicitly insert casts where needed, to ensure at runtime that typing assumptions are not violated by untyped code. However, the implicit nature of cast insertion, especially on higher-order values, can jeopardize reliability and efficiency: higher-order casts can fail at any time, and are costly to execute. We propose Confined Gradual Typing, which extends gradual typing with two new type qualifiers that let programmers control the flow of values between the typed and the untyped worlds, and thereby trade some flexibility for more reliability and performance. We formally develop two variants of Confined Gradual Typing that capture different flexibility/guarantee tradeoffs. We report on the implementation of Confined Gradual Typing in Gradualtalk, a gradually-typed Smalltalk, which confirms the performance advantage of avoiding unwanted higher-order casts and the low overhead of the approach.

SUMMARY In the context of our research on Aspect‐Oriented Programming, we have a need for a modern and powerful aspect language for Smalltalk. Current aspect languages for Smalltalk however fall short on various points. To address this deficit, we elected to design and build PHANtom: a modern aspect language for Pharo Smalltalk. PHANtom is designed to be an aspect language in the spirit of Smalltalk: dynamic, simple, and powerful. PHANtom is a modern aspect language because it incorporates the best features of languages that precede it, includes recent research results in aspect interactions and reentrancy control, and is designed from the onset to be optimized and compiled where possible. In this paper, we present the latest version of the language and give examples and patterns of use. Copyright © 2012 John Wiley & Sons, Ltd.

Gradual typing enables a smooth and progressive integration of static and dynamic typing. The semantics of a gradually-typed program is given by translation to an intermediate language with casts: runtime type checks that control the boundaries between statically- and dynamically-typed portions of a program. This paper studies the performance of different cast insertion strategies in the context of Gradualtalk, a gradually-typed Smalltalk. We first implement the strategy specified by Siek and Taha, which inserts casts at call sites. We then study the dual approach, which consists in performing casts in callees. Based on the observation that both strategies perform well in different scenarios, we design a hybrid strategy that combines the best of each approach. We evaluate these three strategies using both micro- and macro-benchmarks. We also discuss the impact of these strategies on memory, modularity, and inheritance. The hybrid strategy constitutes a promising cast insertion strategy for adding gradual types to existing dynamically-typed languages.

To be able to modularize crosscutting concerns, aspects introduce new programming language features, often in a new language, with a specific syntax. These new features lead to new needs for source code analysis tools, resulting in the requirement for a general-purpose aspectual source code analysis tool. Ignoring this requirement has led to a nontrivial duplication of effort in the aspect-oriented software development community. This is because all code analysis efforts that we are aware of have either built ad-hoc analysis tools or were performed manually. In this paper we present Gasr: a source code analysis tool in the tradition of logic program querying that reasons over AspectJ source code. By hooking into the IDE plugins for AspectJ, Gasr provides a library of predicates that can be used to query aspectual source code. We demonstrate the use of Gasr by automating the recognition of a number of previously identified aspectual source code assumptions. We then detect assumption instances on two well-known case studies that were manually investigated in the earlier work. In addition to finding the already known aspect assumptions, Gasr encounters assumption instances that were overlooked before.

AspectMaps is a visualization that shows the structure of aspectual source code. In its design and implementation we made a number of design decisions that we present and discuss in this text. This in the light of more than two years of using, extending and maintaining the AspectMaps visualization and tool. The purpose of this paper is to share our experience with other visualization designers and implementers, as an aid in the making of their design decisions.

When using Aspect-Oriented Programming, it is sometimes difficult to determine at which join point an aspect executes. Similarly, when considering one join point, knowing which aspects will execute there and in what order is non-trivial. This makes it difficult to understand how the application will behave. A number of visualizations have been proposed that attempt to provide support for such program understanding. However, they neither scale up to large code bases nor scale down to understanding what happens at a single join point. In this paper, we present Aspect Maps -- a visualization that scales in both directions, thanks to a multi-level selective structural zoom. We show how the use of Aspect Maps allows for program understanding of code with aspects, revealing both a wealth of information of what can happen at one particular join point as well as allowing to see the "big picture" on a larger code base. We demonstrate the usefulness of Aspect Maps on an example and present the results of a small user study that shows that Aspect Maps outperforms other aspect visualization tools.

Aspect interactions and conflicts are an important issue for AOSD. Aspectual conflicts are difficult to manage and, specifically semantic ones remain an open issue for AOSD. In this work, we present a simple mechanism for handling semantic conflicts at the granularity of aspect and advice in the resource awareness domain. We also analyze the impact of such coordination mechanism on some important properties of software (some of the so called ilities). We found that aspects can effectively be coordinated and remain independent, improving their reusability, modularity and evolvability.