We have found many programming problems for which neither procedural nor object-oriented programming techniques are sufficient to clearly capture some of the important design decisions the program must implement. This forces the implementation of those design decisions to be scattered throughout the code, resulting in “tangled” code that is excessively difficult to develop and maintain. We present an analysis of why certain design decisions have been so difficult to clearly capture in actual code. We call the properties these decisions address aspects, and show that the reason they have been hard to capture is that they crosscut the system’s basic functionality. We present the basis for a new programming technique, called aspect-oriented programming, that makes it possible to clearly express programs involving such aspects, including appropriate isolation, composition and reuse of the aspect code. The discussion is rooted in systems we have built using aspect-oriented programming.

We describe the extensible Java preprocessor EPP and a data-parallel extension of Java implemented with EPP. EPP can be extended by incorporating EPP plugins. These plugins are programmed with the Ld-2 language that we also describe. Tiny Data-Parallel Java is an example of EPP plugin. High portability is guaranteed because the translated code and the runtime systems are pure Java code. Applications can be executed in parallel if the VM interpreter supports parallel execution of Java threads. We provide a preliminary performance evaluation of this system. 1 Introduction The Java language [GJG96] has recently become very popular among programmers. Java has socket and thread libraries which can be used on various platforms. In the near future, many JAVA VM (virtual machine) interpreters will support shared-memory multiprocessing and will then become a better platform for parallel programming. However, Java lacks facilities for language extension, which have been adopted by other object-...

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...

has been approved for the

Computer programming environments for learning should make it easy to create worlds of responsive and autonomous objects, such as video games or simulations of animal behavior. But building such worlds remains difficult, partly because the models and metaphors underlying traditional programming languages are not particularly suited to the task. This dissertation investigates new metaphors, environments, and languages that make possible new ways to create programs -- and, more broadly, new ways to think about programs. In particular, it introduces the idea of programming with "agents" as a means to help people create worlds involving responsive, interacting objects. In this context, an agent is a simple mechanism intended to be understood through anthropomorphic metaphors and endowed with certain lifelike properties such as autonomy, purposefulness, and emotional state. Complex behavior is achieved by combining simple agents into more complex structures. While the agent metaphor enables...

Abstract. We describe a module mechanism, which we call differencebased modules, and an object-oriented language we call MixJuice. MixJuice is an enhancement to the Java language that adopts difference-based modules instead of Java’s original module mechanism. Modules are units of information hiding, reuse and separate compilation. We have completely separated the class mechanism and the module mechanism, and then unified the module mechanism and the differential programming mechanism. Although this module mechanism is simpler than that of Java, it enhances ease with which programs can be extended, reused and maintained. Collaborations that crosscut several classes can be separated into different modules. Modules are composable in the same way as mixins. The composition of modules sometimes causes name collision and an interesting phenomenon, which we call implementation defects. We describe solutions to these problems. 1

There are many problems with the simplification of elementary functions, particularly over the complex plane. Systems tend to make "howlers" or not to simplify enough. In this paper we outline the "unwinding number" approach to such problems, and show how it can be used to prevent errors and to systematise such simplification, even though we have not yet reduced the simplifiation process to a complete algorithm. The unsolved problems are probably more amenable to the techniques of artificial intelligence and theorem proving than the original problem of complex-variable analysis.

This article presents a polymorphic modal type system and its principal type inference algorithm that conservatively extend ML by all of Lisp’s staging constructs (the quasi-quotation system). The combination is meaningful because ML is a practical higher-order, impure, and typed language, while Lisp’s quasi-quotation system has long evolved complying with the demands from multi-staged programming practices. Our type system supports open code, unrestricted operations on references, intentional variable-capturing substitution as well as capture-avoiding substitution, and lifting values into code, whose combination escaped all the previous systems.

The aspect-oriented programming community devotes lots of energy into the provision of complex static language constructs to reason about eventual dynamic properties of a program.

In [MCD92], we have contributed a reflective model for a prototype-based language based on the lookup ffi apply reflective introspection protocol. Here, we pursue this work by including a reification of continuations. Hence, we provide continuations as first-class objects and convert our previous protocol to handle them. First-class continuations provide much more control over the current computation. Also, this new model establishes the clear link between reflection in object-oriented and reflective towers as examplified by 3Lisp [Smi84]. Object-orientedness provides reflection a more principled and encapsulated programming style, making it easier to use. In this paper, we establish the correctness of this new model, namely that any message in the system will be executed in a finite number of computation steps. This fact is based on a limited number of hypothesis independent from the implementation but from which we derive fundamental clues to derive an evaluator for the language. 1 ...