John Brant’s research while affiliated with University of Evansville and other places

Sometimes projects need to switch implementation languages. Rather than stopping software development and rewriting the project from scratch, transformation rules can map from the original language to the new language. These rules can be developed in parallel to standard software development, allowing the project to be cut over without any loss of development time, once the rules are complete. This paper presents a migration project that used transformation rules to successfully convert 1.5 MLOC of Delphi to C# in 18 months while allowing existing Delphi development to continue.

The SmaCC Transformation Engine is a workbench for building program transformation systems. It has been used to create a wide variety of transformations ranging from simple refactorings to much larger ones, such as converting entire code bases between languages. We will demonstrate how the system works, present a quick overview of the architecture of the generated transformers, describe how typical large scale transformations, such as a migration project, proceeds perform several small transformations of a formula language, and demonstrate some larger, inter-language migrations.

In a commercial system, performing large, invasive changes, such as changing an entire infrastructure layer, is often impossible because development on a system cannot be halted for any significant amount of time. Performing such changes require tools that can perform mass transformations on the source code. One approach is to use tools that can do global search and replace on the entire program structure. However, simple text-based tools are too simplistic for program text. To make accurate changes in a large program the tool must be based on parsing the program text. The paper describes the requirements for such a tool, the shortcomings of this approach, and describes one such tool for the Smalltalk language. This tool, the Refactoring Browser Rewrite Engine, is based on pattern matching of parse trees. The paper then presents three case studies in the successful application of this tool in commercial settings and discusses the shortcomings of such an approach. "impossible adj. - 1 b felt to be incapable of being done, attained, or fulfiled : insuperably difficult. - Merriam-Webster Dictionary".

Wrappers are mechanisms for introducing new behavior that is executed before and/or after, and perhaps even in lieu of, an existing method. This paper examines several ways to implement wrappers in Smalltalk, and compares their performance. Smalltalk programmers often use Smalltalk's lookup failure mechanism to customize method lookup. Our focus is different. Rather than changing the method lookup process, we modify the method objects that the lookup process returns. We call these objects method wrappers.Wehaveused method wrappers to construct several program analysis tools: a coverage tool, a class collaboration tool, and an interaction diagramming tool. We also show how we used method wrappers to construct several extensions to Smalltalk: synchronized methods, assertions, and multimethods. Wrappers are relatively easy to build in Smalltalk because it was designed with reflective facilities that allow programmers to intervene in the lookup process. Other languages differ in the degree to which they can accommodate change. Our experience testifies to the value, power, and utility of openness.

This paper contains a collection of patterns for database reporting applications. While there are many different aspects of reporting, this paper focuses on the ability to create new reports at runtime. It does not discuss user interface issues or good database design. This pattern language consists of patterns that pull data from the database and those that manipulate data after it has been extracted from the database. This is accomplished by converting both queries and formulas into objects. These objects are then assembled into reports through the high-level Report Objects pattern. Introduction These database reporting patterns are based upon our research using VisualWorks Smalltalk to dynamically generate reports that map to a relational database. We discovered these patterns while we were building a Business Modeling tool for Caterpillar. Although these patterns were written with Smalltalk in mind, we feel that they are applicable to anyone building reporting applications. Furthe...

This paper contains a collection of patterns for creating database-reporting applications. While there are many different aspects of reporting, this paper focuses on the ability to dynamically create formulas and queries so that new reports can be generated at runtime. It does not discuss user interface issues or good database design. These patterns pull data from the database and manipulate data after it has been extracted from the database. This is accomplished by converting both queries and formulas into objects. These objects are then assembled into reports through the high-level Report Objects pattern.

The refactoring browser is a complete re-implementation of the standard Smalltalk system browser, which incorporates automatic refactorings into the tool. In addition to the browser, the accompanying Smalllint tool can quickly detect hard-to-find errors and style violations.