For any non-trivial software project, architectural drift is a well-known problem. Over time, the design rules and guidelines governing the software project are no longer obeyed, resulting in that the software becomes more difficult to maintain. While there exist numerous tools — such as code checkers, architecture and design checkers, and source code query languages — that aid in alleviating this problem none of these approaches are tailored towards supporting one of the main languages still in use today in industry, namely Cobol. In this paper we present Cognac, an extension of the IntensiVE tool that allows for documenting and verifying design rules in Cobol systems. Next to discussing the architecture of Cognac, we present a validation of our tool on an industrial, large-scale Cobol system. 1.

In order to alleviate design decay, different program design documentation techniques are used for the specification and detection of design inconsistencies in code. However, these design documentation techniques do not always provide support for the diagnosis and (semi-) automatic correction of such inconsistencies. In case they do, corrective solutions are typically targeted to a reduced set of pre-defined inconsistency problems, and they are not easily customizable to new kinds of consistency checks defined by a user. In particular, they cannot infer possible corrective actions to solve new user-defined inconsistency problems. In this paper, we present a technique for the diagnosis and (semi-) automatic correction of inconsistencies in the context of an existing tool for inconsistency management: IntensiVE. Our technique uses logic abductive reasoning to infer solutions to detected user-defined inconsistencies, starting from basic composable corrective actions. A first prototype implementing our technique on top of IntensiVE is shown.

The aim of this working session on Industrial Realities of Program Comprehension is to exchange and discuss experiences, opportunities, challenges and strategies for the application of program comprehension techniques in industry. In this position paper we focus on a potentially interesting opportunity and challenge for adopting program comprehension techniques, and source code mining techniques in particular, in an industrial setting: mining source code for design regularities. Design regularities are an important aspect of current-day software implementations. Coding conventions, design patterns, programming idioms and architectural constraints are only a few examples of design regularities that govern the implementation of large and complex software systems. Maintaining these regularities in the source code of an evolving software system requires adequate documentation that is continuously monitored and verified for consistency with the source code of that system. The formalism of intensional views [1,2] and their supporting tool-suite IntensiVE 1 [3], for example, permit to document and verify design regularities by means of program queries that group source code entities into views, and that impose constraints over these views. By checking the validity of the views and constraints with respect to the source code, the tool-suite provides fine-grained feedback

Abstract—Companies nowadays rely on outsourcing for the implementation of their software. While outsourcing can reduce the actual development costs for a piece of software, it can also reduce a company’s control over the quality of the delivered software. In light of obtaining maintainable software, it is however important that the delivered software is well-structured and obeys the various design rules that were postulated by a company using an outsourcing partner. This paper reports on a collaboration between academia and industry, where the research tool IntensiVE has been applied to verify the design rules underlying a large-scale COBOL system. We describe how the IntensiVE tool was customized in order to support verification of the COBOL system, and how this academic tool aided in providing an initial quality assessment of the outsourced software system. I.

Maintaining consistency between design and implementation is a fundamental issue in software evolution. Although existing tools and techniques provide support for correcting inconsistencies, they target generally-applicable design rules. Unfortunately, in addition to these common design rules, any software system has an abundance of custom design rules that are very specific to the system at hand. For such custom design rules, verification and correction are often left to the developer or require a considerable investment in the implementation of specific verification and correction meta-programs. HEAL is a framework that alleviates the problem of diagnosing and correcting violations of custom design rules in code. It supports the implementation and automatic inference of corrective actions (i.e., program transformations that may solve a detected design inconsistency. Using an abductive logic reasoner, HEAL infers these corrective actions from the design rules themselves and the code over which these rules are verified. In previous work we showed how simple solutions are generated from a repository of corrective actions to lowlevel structural problems. In this paper, we extend our previous work by showing how multiple solutions affecting the same source code element can be composed, allowing for the correction of complex design inconsistencies.