Jukka Paakki

Attribute grammar paradigms—a high-level methodology in language implementation

Attribute grammars are a formalism for specifying programming languages. They have been applied to a great number of systems automatically producing language implementations from their specifications. The systems and their specification languages can be evaluated and classified according to their level of application support, linguistic characteristics, and degree of automation. A survey of attribute grammar-based specification languages is given. The modern advanced specification languages extend the core attribute grammar model with concepts and primitives from established programming paradigms. The main ideas behind the developed attribute grammar paradigms are discussed, and representative specification languages are presented with a common example grammar. The presentation is founded on mapping elements of attribute grammars to their counterparts in programming languages. This methodology of integrating two problem-solving disciplines together is explored with a classification of the paradigms into structured, modular, object-oriented, logic, and functional attribute grammars. The taxonomy is complemented by introducing approaches based on an implicit parallel or incremental attribute evaluation paradigm.

Generating Application Development Environments for Java Frameworks

An application framework is a collection of classes implementing the shared architecture of a family of applications. A technique is proposed for defining the specialization interface of a framework in such a way that it can be used to automatically produce a task-driven programming environment for guiding the application development process. Using the environment, the application developer can incrementally construct an application that follows the conventions implied by the framework architecture. The environment provides specialization instructions adapting automatically to the application-specific context, and an integrated source code editor which responds to actions that conflict with the given specialization interface. The main characteristics and implementation principles of the tool are explained.

Architecture-centric software evolution by software metrics and design patterns

It is shown how software metrics and architectural patterns can be used for the management of software evolution. In the presented architecture-centric software evolution method the quality of a software system is assured in the software design phase by computing various kinds of design metrics from the system architecture, by automatically exploring instances of design patterns and anti-patterns from the architecture, and by reporting potential quality problems to the designers. The same analysis is applied in the implementation phase to the software code, thus ensuring that it matches the quality and structure of the reference architecture. Finally, the quality of the ultimate system is predicted by studying the development history of previous projects with a similar composition of characteristic software metrics and patterns. The architecture-centric software evolution method is supported by two integrated software tools, the metrics and pattern-mining tool Maisa and the reverse-engineering tool Columbus.

Hypertext support for the information needs of software maintainers

Making changes safely to programs requires program comprehension and satisfaction of the information needs of software maintainers. In this paper we provide insights into improving hypertext-based software maintenance support by analyzing those information needs. There exists a series of four earlier, detailed-level empirical studies on the information needs of professional C program maintainers. We focus on these studies, synthesize their results and determine sources from which the required information might be attained. An experimental research tool, the HyperSoft system, is used to demonstrate the satisfaction of information needs and the system is analytically evaluated against the needs explored by the empirical studies. HyperSoft is based on our transient hypertext approach for software maintenance support. HyperSoft provides automatically generated hypertextual access structures and software visualizations. The results show that transient hypertext is a well-suited representational form of the typically required versatile information. The discussion also covers related tools and the main features for providing the information required by maintainers are identified. The results show that the focus areas of these tools vary considerably.

Automated Hypertext Support for Software Maintenance

A model called HyperSoft is presented, which can be used for viewing programs as hypertext. The main goal in developing the model has been to offer a framework for new program browsing tools to support the maintenance of legacy software in particular. The model consists of four layers: source code as such, its syntactic structure, hypertextual access structures based on the source code and its syntax, and the user interface for viewing and manipulating the source code and the access structures. The access structures are based on a general relational model of program dependencies. Both the hypertextual software model and the program dependency model are language independent and provide for a systematic and automated way of representing programs as different kinds of dependency graphs. The models are implemented in a program browsing tool which analyses C programs and automatically generates relevant hypertextual representations for them, according to requests of the maintainer.

Design patterns in performance prediction

The use of design patterns in object-oriented software development is recommended to improve both the software structure and the development process. On the other hand, their e ect on the performance of the nal product may greatly depend on the particular application and the projected workload. In addition to intentional use, the design may also contain patterns (and anti-patterns) that have not been used on purpose. We propose an approach where all patterns and anti-patterns embedded in the design are discovered by a mining tool and their performance e ects are evaluated using previous experience stored in a pattern library.

Synthesis of Directionality Information for Functional Logic Programs

Many functional logic programming languages are based on reduction of functional expressions. This feature is also provided by many Prolog systems that offer the facility of calling external functions written in non-logic programming languages. A basic requirement is usually that the arguments of the functions must be ground at invocation time, otherwise an error is reported, or the call is delayed until the arguments are sufficiently instantiated. The drawback of the latter method is twofold: (1) the arguments might never be instantiated, and (2) the dynamic checks made by the delaying mechanism are expensive. This paper presents a method, which for a given program identifies a class of atomic goals for which (1) will not occur. Moreover, we describe a method for transforming a program into an equivalent program, for which dynamic delays are avoided. The static analysis is based on the concept of dependency graphs over an automatically annotated program, a technique originally introduced in connection of attribute grammars.

Architecture-oriented programming using FRIED

Implementing application-specific code conforming to architectural rules and conventions can be tedious. We will demonstrate a tool prototype for architecture-oriented programming that takes an architectural description as a set of programming patterns and provides an interactive task-based programming environment for the architecture. Incorporating adaptive code generation and documentation, the tool provides a convenient way to adopt as well as effectively reuse a framework or architectural standard such as Java Beans.

Prolog in practical compiler writing

We discuss the experiences gained with implementing the programming language Edison in Prolog. The evaluation of Prolog in this application area is based on a comparison with two other Edison compilers, one written in Pascal (procedural approach) and the other generated using the compiler writing systems PGS and GAG (declarative approach)

Profit: A system integrating logic programming and attribute grammars

PROFIT is a system and a programming language where Prolog is extended with concepts needed in compiler writing applications. The special facilities include a deterministic error-recovering form of definite clause grammars (DCGs), functions as conditional equations, and functional terms modelling inherited and synthesized attributes of attribute grammars. PROFIT supports a multi-paradigm method of writing compilers in a compact and natural way. Most notably PROFIT can be used to express one-pass compilation within the framework of logical one-pass attribute grammars, a proper superset of L-attributed grammars.