The design and implementation of a software system is often governed by many different coding conventions, design patterns, architectural design rules, and other so-called structural regularities. To prevent a deterioration of the system’s source code, it is important that these regularities are verified and enforced in subsequent evolutions of the system. The Intensional Views Environment (IntensiVE), presented in this article, is a tool suite for documenting such structural regularities in (object-oriented) software systems and verifying their consistency in later versions of those systems.

Abstract—Annotations are a means to attach additional meta data to the source code of a system. Nowadays, more and more technologies rely on the presence of such annotations in the source code: beyond their use for documentation purposes, annotations impact the behaviour of the system. Since there exists little or no support to make sure that upon evolution of the system, the source code remains correctly annotated, source code can become miss-annotated. This in turn, can result in erroneous behaviour. In this paper we present Smart Annotations, an approach for co-evolving source code and annotations. Our approach enables developers to constrain the use of annotations in the source code and offers tool support to identify conflicts between source code and annotations. To illustrate the use of our approach, we demonstrate its applicability using examples from the domain of aspect-oriented programming and Enterprise Java Beans. I.

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.