Many tools designed to help programmers view and manipulate source code exploit the formal structure of the programming language. Language-based tools use information derived via linguistic analysis to offer services that are impractical for purely text-based tools. In order to be effective, however, language-based tools must be designed to account properly for the documentary structure of source code: a structure that is largely orthogonal to the linguistic but no less important. Documentary structure includes, in addition to the language text, all extra-lingual information added by programmers for the sole purpose of aiding the human reader: comments, white space, and choice of names. Largely ignored in the research literature, documentary structure occupies a central role in the practice of programming. An examination of the documentary structure of programs leads to a better understanding of requirements for tool architectures.

In this paper we explain how we implemented traceability between a UML design specification and its implementing source code using XML technologies. In our linking framework an XMI file represents a detaileddesign specification and a JavaML file represents its source code. These XML-derivative representations were linked using another XML file, an Xlink link-base, containing our linking information. This link-base states which portions of the source code implement which portions of a design specification and vice-versa. We also rendered those links to an HTML file using XSL and traversed from our design specification to its implementing source code. This is the first step in our traceability endeavors where we aim to achieve total traceability among software life-cycle deliverables form requirements to source code.

Today's critical systems increasingly rely on computers and software. However, market pressure, problems in the application of formal methods, and ineffective traceability techniques may all exacerbate the difficulty of applying adequate assurance techniques to the design and development of safe and trustworthy systems. Necessity dictates that engineers target critical sections that require formal verification and high reliability. To achieve this objective, we need to implement and maintain linking relationships among system work products and be able to propagate criticality of requirements to subsequent work products. We successfully implemented traceability between an informal requirements document and its formal specification using two new XML-derived markup languages. We addressed the issues of specifying and propagating criticality of requirements and consistency of this determination within and between work products.

When an expression refers to a memory location that is referred to by another expression, we say that there is an alias relation between those expressions. Alias analysis, i.e, the extraction of such relations is essential for efficient maintenance of object-oriented programs. Although many researchers have already proposed analysis methods and implemented pro-totype tools for object-oriented programs, difficulties still remain in applying such methods to practical tools in the sense of precision, extensibility, and scalability. Focusing mainly on prac-tical implementation, we propose an alias analysis method for object-oriented programs. This method employs a two-phase, on-demand, instance-based, and extensible algorithm. We have implemented the proposed method as JAAT. JAAT can analyze large programs such as Java Developer’s Kit (JDK) class library. We have applied JAAT to various large Java programs and confirmed JAAT’s performance.

ing refactoring techniques [6]. The obtained results can be visualized using graphs and tables in VISUR. Analysis of Software The system VISUR/RAR supports developers in the comprehension and the further development of software projects in PROLOG or JAVA. VISUR makes it easy for the user to become acquainted with the source code by visualizing coherences between different source files of a project or by visualizing rule calls. Using RAR it is possible to analyze source code customized to the individual needs of a user -- and to visualize the results graphically or in tables with VI- SUR. For example it is possible to answer the following questions using RAR: Which parts (files, modules) of a project are needed in order to make a specific predicate work correctly ? Which predicates call predicates from other modules, and which of them transitively call themselves, i.e., are recursive ? Which relationships exist between classes and methods in JAVA--source code ? We have alrea