Modules and classes provide many of the same mechanisms. They both provide structure to the name space, scoping, data abstraction, and type abstraction. Perhaps because of this overlap, class-based languages, like C++ and Java, tend to have weak or non-existent module systems and the few languages with both objects and rich module systems do not have elaborate class mechanisms.
While modules and classes have overlap, they also have significant differences, which makes it desirable to include both in a language design. The hard problem is how to do this without blowing the complexity budget, and without substantial redundancy.
We are working on the design of a language with a rich module system and class-based objects. In this talk, I will discuss the design goals for the class mechanism, and how we have met them. In particular, we have a simple class mechanism that complements the module system with little or no overlap, while supporting all of the idioms found in complex class-based languages.
This is join work with Kathleen Fisher of AT&T Labs --- Research.
Dynamic type dispatch has been proposed for type-based compilation, in specialized data representations, tagless garbage collection, etc. We consider an approach to reifying dynamic type dispatch to the programmer level in a type-safe way. This approach is based on the use of "refinement kinds" to constrain type variables. A particular application of this approach is in explicit pickle types and user-defined marshalling for polymorphic languages.
Modern compilers for ML-like polymorphic languages have used explicit run-time type passing to support advanced optimizations such as intensional type analysis, dynamic type dispatch, and tagless garbage collection. Unfortunately, maintaining type information at run time can incur large overhead to the time and space usage of a program. In this paper, we present an optimal type-lifting algorithm that lifts all type applications in a program to the top level. Our algorithm eliminates all run-time type constructions within any core-language functions. We present our algorithm as a type-preserving source-to-source transformation and show how to extend it to handle the entire SML'97 with higher-order modules.
This is a joint work with Zhong Shao.
The ability to quickly replay long-running programs to any point in their execution has many applications in debugging, dynamic program analysis, system understanding, and safety-critical systems. Historically, though, replay-quality tracing has been hampered by impractical slowdowns and trace data rates.
In 1994, Rob Netzer of Brown University reported on a novel method of tracing which relies on dynamic data flow analysis of running programs, at the assembly code level, to achieve acceptable impacts. Dr. Netzer and his colleagues at Brown, working in cooperation with Siemens Corporate Research, last year demonstrated an experimental trace-and-replay system. This system achieves slowdowns comparable to existing code coverage tools, with trace data rates that should be acceptable for a much wider family of applications. This replay system has been demonstrated as part of a Replay Debugger on the SPARC platform.
Recently I've spent some time trying to dig through the hype and understand Microsoft's component object model (COM). In this talk, I will give overview of COM and describe the environment in which it is suppose to operate.