A method and a corresponding tool is described which assist design recovery and program understanding by recognising instances of design patterns semi-automatically. The approach taken is specifically designed to overcome the existing scalability problems caused by many design and implementation variants of design pattern instances. Our approach is based on a new recognition algorithm which works incrementally rather than trying to analyse a possibly large software system in one pass without any human intervention. The new algorithm exploits domain and context knowledge given by a reverse engineer and by a special underlying data structure, namely a special form of an annotated abstract syntax graph. A comparative and quantitative evaluation of applying the approach to the Java AWT and JGL libraries is also given.

Abstract Incremental parsing has long been recognized as a technique of great utility in the construction of language‐based editors, and correspondingly, the area currently enjoys a mature theory. Unfortunately, many practical considerations have been largely overlooked in previously published algorithms. Many user requirements for an editing system necessarily impact on the design of its incremental parser, but most approaches focus only on one: response time. This paper details an incremental parser based on LR parsing techniques and designed for use in a modeless syntax recognition editor. The nature of this editor places significant demands on the structure and quality of the document representation it uses, and hence, on the parser. The strategy presented here is novel in that both the parser and the representation it constructs are tolerant of the inevitable and frequent syntax errors that arise during editing. This is achieved by a method that differs from conventional error repair techniques, and that is more appropriate for use in an interactive context. Furthermore, the parser aims to minimize disturbance to this representation, not only to ensure other system components can operate incrementally, but also to avoid unfortunate consequences for certain user‐oriented services. The algorithm is augmented with a limited form of predictive tree‐building, and a technique is presented for the determination of valid symbols for menu‐based insertion. Copyright © 2001 John Wiley & Sons, Ltd.

Abstract. The refinement calculus for the development of programs from specifications is well suited to mechanised support. We review the requirements for tool support of refinement as gleaned from our experience with existing refinement tools, and report on the design and implementation of a new tool to support refinement based on these requirements. The main features of the new tool are close integration of refinement and proof in a single tool (the same mechanism is used for both), good management of the refinement context, an extensible theory base that allows the tool to be adapted to new application domains, and a flexible user interface.

Current process support systems seek to impose a process structure which controls the work of participants in co-operative work activities. This structure is based on the false premise that the global order emergent from the chaotic dynamics of work processes can be used to prescribe local activity which is in fact situated and unpredictable. A spatial approach to the support of cooperative work processes is proposed. A space of work is defined, incorporating service, information, role and artefact objects, to capture the bounds and characteristics of the global order. The situated reality of work processes is supported by enabling participants to compose objects dynamically to form their own process path through the space.

Abstract We present an incremental semantic analysis strategy for use in language‐based editors. Its advantage is the low storage cost involved in achieving incremental semantic operation with a relatively small loss in response. The scheme, which involves limiting identifier attribute flow, is first described for a simple block‐structured language like Pascal, and then extended to more modern modular languages.

Abstract This paper reviews the design issues that arise in the construction of effective language‐based editors for the preparation of syntactically and static semantically correct language sentences, typically computer programs. The need for such editors to support a pluralistic view of program structure is identified, together with the need to observe the constraints on performance and storage consumption if such editors are to be accepted by professional programmers. From these basic needs, more specific requirements for the display, parsing and semantic checking components of such an editor are derived.

Abstract This paper presents a systematic approach to formatted language design that incorporates formatting within the syntax of programming languages. The approach includes: a metasyntax to ensure that program text is foldable, not only to avoid right margin overflow but also to preclude constructs which are visually confusing or ambiguous; a set of guidelines for language designers to enhance readability within the constraints of the metasyntax; and a folding algorithm which selectively folds a program text. The resulting automatic formatting is consistent with current practice in program and text layout. The effect of this approach is to put program format decisions in the domain of the language's designer, rather than its several implementors or numerous users, which implies uniformly formatted programs of improved readability and therefore usability.

Abstract A previous paper compared the mechanisms for process communication in Hoare's communicating sequential processes and in Brinch Hansen's distributed processes, by both qualitative and quantitative analyses. This paper extends these analyses to the corresponding features for communication between tasks in Ada. The similarity between Ada's features and Hoare's proposals is confirmed, but some limitations on non‐determinism in Ada are noted.

Abstract This paper provides a description of the programming language Pascal. It has been published to enable those without easy access to the official BSI ‘draft for comment’ to comment on the description.

Abstract This paper informally describes the programming language Pascal‐Plus. The language is an extended version of Pascal, incorporating the envelope construct which is an aid to program modularization and data abstraction, the process, monitor and condition constructs which provide a means for representing multiprocessing programs, and a simulation monitor which provides pseudo‐time control facilities for multiprocessing programs.

Abstract A Pascal implementation is described which exploits the information provided by subrange type declarations to minimize the run‐time checking involved in detecting range violations. An evaluation of its performance is given, and some possible modifications are discussed.

Abstract Ambiguities and insecurities in the programming language Pascal are discussed.

Abstract The transport of a PASCAL compiler from a CDC 6000 series computer to an ICL 1900 series computer is reported, with some comments on the method used.