The classical plain-text representation of source code is convenient for programmers but requires parsing to uncover the deep structure of the program. While sophisticated software tools parse source code to gain access to the program's structure, many lightweight programming aids such as grep rely instead on only the lexical structure of source code. I describe a new XML application that provides an alternative representation of Java source code. This XML-based representation, called JavaML, is more natural for tools and permits easy specification of numerous software-engineering analyses by leveraging the abundance of XML tools and techniques. A robust converter built with the Jikes Java compiler framework translates from the classical Java source code representation to JavaML, and an XSLT stylesheet converts from JavaML back into the classical textual form. Keywords: Java, XML, abstract syntax tree representation, software-engineering analysis, Jikes compiler. 1 Introduction Since...

A generic procedure can be specialized, by compilation through views, to operate directly on concrete data. A view is a computational mapping that describes how a concrete type implements an abstract type. Clusters of related views are needed for specialization of generic procedures that involve several types or several views of a single type. A user interface that reasons about relationships between concrete types and abstract types allows view clusters to be created easily. These techniques allow rapid specialization of generic procedures for applications. Index Terms -- software reuse, view, generic algorithm, generic procedure, algorithm specialization, partial evaluation, direct-manipulation editor, abstract data type. 1 Introduction Reuse of software has the potential to reduce cost, increase the speed of software production, and increase reliability. Facilitating the reuse of software could therefore be of great benefit. G. S. Novak, Jr. is with the Department of Comput...

Domain specific languages (DSLs) have proven to be a very adequate mechanism to encapsulate and hide the complex implementation details of component-based software development. Since evolution lies at the heart of any software system the DSLs that were built around them must evolve as well. In this paper we identify important issues that cause a DSL implementation to be very rigid in which all phases are tightly coupled and highly dependent upon one another. To increase the poor evolvability of current day DSL development environments a new development environment Keyword based programming (KBP) is proposed where DSLs are built by using a language specification to compose and glue loosely coupled and independent language components (called keywords).

Transformation rules are often used to implement compilers for domain-specific languages. In an ideal situation, each transformation rule is a modular unit transforming one input element of the source program into a new element of the output program. However, in practice, transformation rules must be written which take one input element and produce several new elements belonging to various locations in the output program, the so-called local-to-global transformations. The implementation of such transformations is very complex and tightly coupled which imposes severe constraints on maintenance and evolvability. In this paper, we propose a transformation architecture on top of rewrite rules to loosen this coupling. The resulting transformation system combines the simplicity and modularity properties of rewrite rules with a new semi-automatic composition system that enables the implementation of local-to-global transformations without hampering maintenance and future evolutions.

ii Dedicated to my wife Linda and my children Jonathan and Daniel for their encouragment and support. iii Acknowledgements I thank my advisor, Kenneth Baclawski for his support over the years that it took to complete this research. Ken was always quick tounderstand my own e orts, and came up with a great many useful suggestions, which Iwas able to incorporate. Iwould like to also thank Karl Lieberherr, who encouraged me from the outset. It was in Karl's classes, and also in the Demeter Seminar, which he directs, that I came up with much of the inspiration for my work. In that vein,Iwould also like to thank the other students and faculty members who participated in the seminar. I would like to thank Ernesto Guerrieri, from whom I gained a great deal of insight into Java at a tutorial that he gave. Ernesto provided valuable input, particularly towards the end. I was able to learn a lot from his experiences as a practitioner in industry. Will Clinger helped me greatly in informal conversations, and in his painstaking examination of my work. I learned a great deal from my Professors at the College of Computer Science. In particular, I would like to thank Agnes Chan, Larry Finkelstein, Ron Williams and Raoul Smith. While

Multi-paradigm software development is a spontaneous answer to attempts of nding the best paradigm. It was present in software development at the level of intuition and practiced as the \implementation detail" without even mentioning it in the design. Its breakthrough is twofold: several recent programming paradigms are encouraging it, while explicit multi-paradigm approaches aim at its full-scale support.

The Whole Platform is a technology for engineering the production of software. We think that programming is an activity concerning the development of languages; so, we provide an environment for developing new languages and tools in a much easier way than now.

Several operating systems projects revolve around moving functionality above or below the kernel "red line" to increase flexibility or performance. We describe how a general model of partial evaluation encompasses this trend. The operating systems community should not be content with a single interface between applications and the operating system, even if that interface allows extension below the red line; we contend that partial evaluation will be most effective when it is free of that arbitrary, static interface. Extending partial evaluation from the language level down to the hardware provides a consistent, global framework for application support.

Project Sponsor