PLDI'99 Tutorial Program

Object-oriented (OO) languages revitalized the notion of software frameworks as a way of expressing stereotypical application structures. In framework based development, parts of the framework are used as is, while other parts are specialized by the developer to provide behavior that is not part of the framework or to override standard behavior that is part of the framework. Frameworks are not patterns, though they may be used to help implement patterns, along with delegation and other programming strategies. Frameworks became relatively common in User Interface programming. UI tools, such as visual builders, rely heavily on these frameworks when they generate code. More recently, frameworks have emerged which support the development of transacted OO applications on so-called "application servers". IBM's Component Broker has such a framework; another framework is defined by the Enterprise Java Bean specification. There are two significant challenges posed by framework based development: (1) defining and evolving the framework without destroying applications written to prior versions of the framework; (2) guiding the developer through the sequence of tasks required by the framework. The first of these challenges is largely unsolved and thought to be infeasible in its most general form. The tutorial will concentrate on ways to evolve frameworks in specific ways that minimize the impact on the applications. The second challenge has been met with particular solutions for both Component Broker and Enterprise Java Beans. The tutorial will show examples of tools that exemplify both solutions and discuss the development strategy embedded in the tools. It remains to be seen whether there are other particular solutions which guide and assist the developer who must work within the confines of a framework.

Jim Rhyne is one of the senior technical architects for IBM's Component Broker application server product. He is currently responsible for development tools for this product. Jim joined IBM in 1977 in the Research Division. In 1994, he left IBM Research to work on development tools in IBM's Software group. He holds a Ph.D from the University of Texas.

In February 1958, a paper describing the "Universal Computer-Oriented Language (UNCOL)" was published in Communications of the ACM. In modern parlance, this paper described a virtual machine, an intermediary between the statements and operators of high-level programming languages and the register numbers and opcodes of native machine programming languages. During the forty years since then, the programming language community has articulated many benefits to virtualized program execution, including whole program optimization, targeting of diverse processors, and insertion of meta-capabilities such as debugging, fault tolerance, and performance monitoring. However, only in the past decade have hardware and software advances enabled the development of practical runtime systems for virtual machine languages--systems that approach or even exceed the performance of programs compiled directly to the native machine. This tutorial will describe the history of virtual machines and their runtime systems, provide context for the current generation of systems, and illustrate the role of virtual machines as Internet infrastructure. The bulk of the tutorial will focus on design tradeoffs and implementation techniques for constructing efficient virtual machine systems. We will examine several research and industrial virtual machine systems and describe in detail the impact of their design on their capabilities and performance. Specific topics will include just-in-time compilation, program compression, and bytecode verification. This tutorial is aimed for those interested in mobile code, network computing, virtual machine design, virtual machine implementation and programming language runtime systems.

Steven Lucco has researched programming language runtime systems since 1985, with publications on the topic in PLDI, POPL, SOSP, OOPSLA, and ICDCS. In February 1994, he co-founded Colusa Software in Berkeley, California. In August 1995, Colusa shipped Omniware, a high-performance, language-independent virtual machine system. In February 1996, Colusa joined forces with Microsoft to develop virtual machine technology for the Internet and to incorporate that technology into the Windows operating system. Dr. Lucco received a B.S. in 1985 from Yale College, and a Ph.D. in 1994 from the University of California, Berkeley. From 1994-1996, he was an assistant professor of Computer Science at Carnegie Mellon University as well as chief technical officer at Colusa Software. Currently, he is a senior researcher at the Microsoft Bay Area Research Center.

This tutorial will examine the role of programming language methods in computer security, especially for mobile code systems like Java and JavaScript. These systems use programming language methods, rather than the usual memory protection methods, to separate mutually untrusting software components from each other. In this tutorial, we will examine methods of enforcing separation between untrusting components, including load-time type checking, proof-carrying code, and value labeling. We will discuss the limits of these separation techniques for enforcing security, and survey some ways of augmenting the separation methods to build secure systems. Finally, we will explore how the use of programming language technologies for security enables new types of software to be practical.

Edward W. Felten is Assistant Professor of Computer Science, and Director of the Secure Internet Programming Laboratory, at Princeton University. His research interests include computer security, mobile code security, operating systems, and distributed computing. He has written several papers on mobile code security, especially relating to Java, and is co-author with Gary McGraw of the book Securing Java: Getting Down to Business with Mobile Code. He received his Ph.D. in Computer Science from the University of Washington in 1993.