There are obvious reasons for trying to automate the production of multilingual documen- tation, especially for routine subject-matter in restricted domains (e.g. technical instructions). Two approaches have been adopted: Machine Translation (MT) of a source text, and Multilingual Natural Language Generation (M-NLG) from a knowledge base. For MT, information extraction is a major difficulty, since the meaning must be derived by analysis of the source text; M-NLG avoids this difficulty but seems at first sight to require an expensive phase of knowledge engineering in order to encode the meaning. We introduce here a new technique which employs M-NLG during the phase of knowledge editing. A 'feedback text', generated from a possibly incomplete knowledge base, describes in natural language the knowledge encoded so far, and the options for extending it. This method allows anyone speaking one of the supported languages to produce texts in all of them, requiring from the author only expertise in the subject-matter, not expertise in knowledge engineering.

Many kinds of knowledge-based system would be easier to develop and maintain if domain experts (as opposed to knowledge engineers) were in a position to define and edit the knowledge. From the viewpoint of domain experts, the best medium for defining the knowledge would be a text in natural language; however, natural language input cannot be decoded reliably unless written in controlled languages, which are difficult for domain experts to learn and use. WYSIWYM editing is an alternative solution in which the texts employed to view and edit the knowledge are generated not by the user but by the system. The user can add knowledge by clicking on `anchors' in the text and choosing from a list of semantic alternatives; each choice directly updates the knowledge base, from which a new text is then generated. 1 KNOWLEDGE EDITING Many applications require editing of information expressed in a knowledge representation formalism. Expert systems are an obvious example; others are systems for gen...

Reverse engineering software systems has become a major concern in software industry because of their sheer size and complexity. This problem needs to be tackled, since the systems in question are of considerable worth to their owners and maintainers. In this article we present the concept of a polymetric view, a lightweight software visualization technique enriched with software metrics information. Polymetric views help to understand the structure and detect problems of a software system in the initial phases of a reverse engineering process. We discuss the benefits and limits of several predefined polymetric views we have implemented in our tool CodeCrawler. Moreover, based on clusters of different polymetric views we have developed a methodology which supports and guides a software engineer in the first phases of a reverse engineering of a large software system. We have refined this methodology by repeatedly applying it on industrial systems, and illustrate it by applying a selection of polymetric views to a case study.

In the past, attempts to extend the spreadsheet paradigm to support graphical objects, such as colored circles or user-defined graphical types, have led to approaches featuring either a direct way of creating objects graphically or strong compatibility with the spreadsheet paradigm, but not both. This inability to conveniently go beyond numbers and strings without straying outside the spreadsheet paradigm has been a limiting factor in the applicability of spreadsheet languages. In this paper we present graphical definitions, an approach that removes this limitation, allowing both simple and complex graphical objects to be programmed directly using direct manipulation and gestures, in a manner that fits seamlessly within the spreadsheet paradigm. We also describe an empirical study, in which subjects programmed such objects faster and with fewer errors using this approach than when using a traditional approach to formula specification. Because the approach is expressive enough to be used with both built-in and user-defined types, it allows the directness of demonstrational and spreadsheet techniques to be used in programming a wider range of applications than has been possible before.

Abstract—Understanding source code is an important task in the maintenance of software systems. Legacy systems are not only limited to procedural languages, but are also written in object-oriented languages. In such a context, understanding classes is a key activity as they are the cornerstone of the object-oriented paradigm and the primary abstraction from which applications are built. Such an understanding is however difficult to obtain because of reasons such as the presence of late binding and inheritance. A first level of class understanding consists of the understanding of its overall structure, the control flow among its methods, and the accesses on its attributes. We propose a novel visualization of classes called class blueprint that is based on a semantically enriched visualization of the internal structure of classes. This visualization allows a software engineer to build a first mental model of a class that he validates via opportunistic code-reading. Furthermore, we have identified visual patterns that represent recurrent situations and as such convey additional information to the viewer. The contributions of this article are the class blueprint, a novel visualization of the internal structure of classes, the identification of visual patterns, and the definition of a vocabulary based on these visual patterns. We have performed several case studies of which one is presented in depth, and validated the usefulness of the approach in a controlled experiment. Index Terms—Object-oriented programming, software visualization, reverse engineering, visual patterns, smalltalk. 1

The past decade has witnessed the emergence of an active visual programming research community.Yet, there has also been a noteworthy shortage of empirical evidence supporting the resulting research. This paper summarizes empirical data relevant to visual programming languages, both to show the current empirical status and to act as a call to arms for further empirical work.

Large software projects often require a programmer to make changes to unfamiliar source code. This paper presents the results of a formative observational study of seven professional programmers who use a conventional development environment to update an unfamiliar implementation of a commonly known video game. We describe several usability problems they experience, including keeping oriented in the program’s source text, maintaining the number and layout of open text documents and relying heavily on textual search for navigation. To reduce the cost of transferring knowledge about the program among developers, we propose the idea of wear-based filtering, a combination of computational wear and social filtering. The development environment collects interaction information, as with computational wear, and uses that information to direct the attention of subsequent users, as with social filtering. We present sketches of new visualizations that use wear-based filtering and demonstrate the feasibility of our approach with data drawn from our study.

A weakness of many interactive visual programming languages (VPLs) is their static representations. Lack of an adequate static representation places a heavy cognitive burden on a VPL s programmers, because they must remember potentially long dynamic sequences of screen displays in order to understand a previously written program. However, although this problem is widely acknowledged, research on how to design better static representations for interactive VPLs is still in its infancy. Building upon the cognitive dimensions developed for programming languages by cognitive psychologists Green and others, we have developed a set of concrete benchmarks for VPL designers to use when designing new static representations. These benchmarks provide design-time information that can be used to improve a VPL s static representation.

Object-oriented programming has, in recent years, become the most influential programming paradigm. It is widely ised in education and industry...

This paper describes a multi-perspective software visualization environment, SHriMP, which combines single view and multi-view techniques to support software exploration at both the architectural and source code levels. SHriMP provides three different views: a primary nested view and two subsidiary views. The primary nested view employs fisheye views of nested graphs, provides contextual cues, and supports general exploration activities. In SHriMP, subsidiary views exist as a searching tool and a relation tracer. These views complement each other and allow programmers to examine a software system from multiple perspectives.