A lightweight mechanism to update code in a running program Techniques for dynamically adding new code to a running program already exist in various operating systems, programming languages and runtime environments. Most of these systems have not found their way into common use, however, since they require programmer retraining and invalidate previous software investments. In addition, many of the systems are too high-level for performance-critical applications. This paper presents an implementation of dynamic classes for the C++ language. Dynamic classes allow run-time updates of an executing C++ program at the class level. Our implementation is a lightweight proxy class that exploits only common C++ features and can be compiled with

gperf is a "software-tool generating-tool" designed to automate the generation of perfect hash functions. This paper describes the features, algorithms, and object-oriented design and implementation strategies incorporated in gperf.Italso presents the results from an empirical comparison between gperf-generated recognizers and other popular techniques for reserved word lookup. gperf is distributed with the GNU libg++ library and is used to generate the keyword recognizers for the GNU C and GNU C++ compilers. 1 Introduction Perfect hash functions are a time and space efficient implementation of static search sets, which are ADTs with operations like initialize, insert,andretrieve. Static search sets are common in system software applications. Typical static search sets include compiler and interpreter reserved words, assembler instruction mnemonics, and shell interpreter builtin commands. Search set elements are called keywords.Key- words are inserted into the set once, usually at c...

It is becoming increasingly clear that, if a useful device for quantum computation will ever be built, it will be embodied by a classical computing machine with control over a truly quantum subsystem, this apparatus performing a mixture of classical and quantum computation. This paper investigates a possible approach to the problem of programming such machines: a template high level quantum language is presented which complements a generic general purpose classical language with a set of quantum primitives.

Cetus is a compiler infrastructure for the source-to-source transformation of programs. We created Cetus out of the need for a compiler research environment that facilitates the development of interprocedural analysis and parallelization techniques for C, C++, and Java programs. We will describe our rationale for creating a new compiler infrastructure and give an overview of the Cetus architecture. The design is intended to be extensible for multiple languages and will become more flexible as we incorporate feedback from any di#culties we encounter introducing other languages. We will characterize Cetus' runtime behavior of parsing and IR generation in terms of execution time, memory usage, and parallel speedup of parsing, as well as motivate its usefulness through examples of projects that use Cetus. We will then compare these results with those of the Polaris Fortran translator.

Abstract not found

ion in the Bridge pattern [9]. D. Determine where to encapsulate platform-specific variation: Minimizing platform-specific application code is an important benefit of using the Wrapper Facade pattern. Thus, although wrapper facade class method implementations may differ across different OS platforms they should provide uniform, platform-independent interfaces. There are two general strategies for determining how to encapsulate platform-specific implementation variation: 1. One is to #ifdefs the wrapper facade class method implementations. When #ifdefs are used in conjunction with auto-configuration tools, such as GNU autoconf, platform-independent wrapper facades can be created with a single source tree. 2. Another strategy is to factor out different wrapper facade class implementations into separate directories, e.g., one per platform, and configure the language processing tools to include the appropriate wrapper facade class into applications at compile-time. Choosing a particula...

Combinations of C++ features, like inheritance, templates, and class nesting, allow for the expression of powerful component patterns. In particular, research has demonstrated that, using C++ mixin classes, one can express layered component-based designs concisely with efficient implementations. In this paper, we discuss pragmatic issues related to component-based programming using C++ mixins. We explain surprising interactions of C++ features and policies that sometimes complicate mixin implementations, while other times enable additional functionality without extra effort.

When it comes to software that runs on devices as varied as cell phones, PDAs and desktops, one size does not fit all. This paper describes how mixin layers, a kind of nested generic type, can be used to implement a graphical user interface library that can be configured to run on platforms with widely dissimilar capabilities. We describe the language support needed to incrementally build software in layers, and we describe how crosscutting concerns can be encapsulated within a layer. We then show how layers can be reconfigured to meet changing requirements. We also show how a new design pattern, the Sibling pattern, can be used with mixin layers to coordinate changes to multiple classes in the same inheritance hierarchy. When used appropriately, the Sibling pattern increases our ability to separate design concerns and to reuse code.

Multiple inheritance is still a controversial feature in traditional object-oriented languages, as evidenced by its omission from such languages as Modula-3, Objective C and Java^TM. Nonetheless, users of such languages often complain about having to work around the absence of multiple inheritance. Automating delegation, in combination with a multiple subtyping mechanism, provides many of the same benefits as multiple inheritance, yet sidesteps most of the associated problems. This simple feature could satisfy both the designers and the users of class based object oriented languages. In this paper, we discuss why automated delegation is desirable. We also present Jamie, a freeware preprocessor-based extension to Java that offers such an alternative. Automated Delegation is a Viable Alternative to Multiple Inheritance in Class Based Languages John Viega Dept. Of Computer Science University Of Virginia Charlottesville, VA 22903 viega@list.org Bill Tutt Microsoft Corporat...

At present, the only means used for specifying design patterns are contemporary object notations [Rumbaugh et. al 91; Booch 94], lengthy verbal descriptions, and sample programs. The inherent ambiguity and incompleteness of these means preclude devising tool support and fuel disputes over "their true intention". We identified a compact set of abstractions with simple graphical representation, which translates to precise, higher-order logic language. The visual language we present was construed to straightforwardly reflect regularities in design patterns and in O-O software in general. Several illuminating examples are analyzed to demonstrate the use of this language. Keywords: Design patterns, category theory, formal methods, software architecture 1. Introduction Despite vast interest in design patterns [GoF 95; Coplien & Schmidt 95; Vlissides, Coplien & Kerth 96; Buschmann et. al 96; Pree 94], and in the "pattern" form as means of conveying expertise in software design, little had be...