Titanium is an explicitly parallel dialect of Java developed at UC Berkeley  to support high-performance scientific computing on large-scale multiprocessors, including massively parallel supercomputers and distributed-memory clusters with one or more processors per node. Other language goals include safety, portability, and support for building complex data structures.
The main additions  to Java are:
Titanium provides a global memory space abstraction (similar to other languages such as Split-C and UPC) whereby all data has a user-controllable processor affinity, but parallel processes may directly reference each other's memory to read and write values or arrange for bulk data transfers. A specific portability result is that Titanium programs can run unmodified on uniprocessors, shared memory machines, and distributed memory machines. Performance tuning may be necessary to arrange an application's data structures for distributed memory, but the functional portability allows for development on shared memory machines and uniprocessors.
Titanium is a superset of Java and inherits all the expressiveness, usability, and safety properties of that language. Titanium augments Java's safety features by providing checked synchronization that prevents certain classes of synchronization bugs. To support complex data structures, Titanium uses the object-oriented class mechanism of Java along with the global address space to allow for large shared structures. Titanium's multidimensional array facility adds support for high-performance hierarchical and adaptive grid-based computations.
Our compiler research focuses on the design of program analysis techniques and optimizing transformations for Titanium programs, and on developing a compiler and run-time system that exploit these techniques. Because Titanium is an explicitly parallel language, new analyses are needed even for standard code motion transformations. The compiler analyzes both synchronization constructs and shared variable accesses. Transformations include cache optimizations, overlapping communication, identifying references to objects on the local processor, and replacing runtime memory management overhead with static checking. Our current implementation translates Titanium programs entirely into C, where they are compiled to native binaries by a C compiler and then linked to the Titanium runtime libraries (there is no JVM).
The current implementation runs on a wide range of platforms, including uniprocessors, shared memory multiprocessors, distributed-memory clusters of uniprocessors or SMPs (CLUMPS), and a number of specific supercomputer architectures (Cray T3E, IBM SP, Origin 2000). The distributed memory back-ends can use a wide variety of high-performance network interconnects, including Active Messages, MPI, IBM LAPI, shmem, and UDP.
Titanium is especially well adapted for writing grid-based scientific parallel applications, and several such major applications have been written and continue to be further developed ([3,4], and many others).
Society is increasingly dependent on the robustness, reliability, and evolvability of software systems. Better support for software development and maintenance are essential. The goal of our research is to build interactive systems that enable developers to work at a more conceptual level and to reduce their dependence on typing and text. That will help developers to be more productive and to create better software; at the same time, it will reduce the incidence of repetitive strain injuries, and provide tools for people with motor disabilities.
We are using two approaches to providing high-level interaction. We will enable the user to manipulate software at a conceptual level by creating powerful language-based generative, navigation, and transformation capabilities. We will create multi-modal voice and gesture-based interaction to access and use those capabilities.
Our prototype system is built on our Harmonia language-based framework, an integrated set of language-based tools and services that provides an annotated structural representation of programs, together with an embedded history of changes and support for incomplete or incorrect versions during the development process. It is designed to provide language-aware support for the myriad of formally specified system architecture, specification, design, programming, scripting, and command languages used by developers. The technology can be used to create multi-lingual and language-portable development environments or to create new tools for existing environments.
Software development environments have not changed very much in the past thirty years. While developers discuss software artifacts with one another in terms of high-level conceptual notions, their environments force them to use low-level text editors and program representations designed for compiler input. This shift in level is error-prone and inefficient; in addition, the environments create frustrating barriers for the growing numbers of software developers that suffer from repetitive strain injuries and other related disabilities that make typing difficult or impossible. Our research helps to lower those barriers by enabling developers to work at a more conceptual level and by reducing their dependence on typing and text.
The specific technical issues to be addressed in this research are driven by two approaches: multi-modal (notably speech) interaction, and semantic and structural search, navigation, and transformation. The technology we are creating is not limited to programming languages; it extends to other specification, design, and command languages that are used by developers and that can be formally defined. Our research will be embedded in the Harmonia framework, also being developed at UC Berkeley. The first prototype language for which the linguistically-based methods will be created is Java.
Our research will create the first version of a form of Java that is more naturally verbalized by human developers than the standard Java language. Methods will be created to translate this form to the same annotated abstract syntax representation used by conventional text-based tools. The major technical challenge is to resolve the ambiguities that the new form allows. That ambiguity resolution requires new algorithms for interacting lexical, syntactic, semantic, and program-specific analysis. New methods of accommodating lexical, syntactic, and semantic errors and inconsistencies will be created in order to sustain language-based services when the artifacts are incomplete and incorrectly formed.
Software design is a complex and cognitively taxing task. A design can rarely be finalized upfront: refined requirements and unforeseen constraints are likely to cause evolution of a design, necessitating changes to an implementation that is already under way. Unfortunately, software source code is not easily amenable to design changes. Many restructuring modifications are complicated by the interdependencies of a typical programming language notation. Furthermore, some of the design abstractions, such as synchronization or logging, are difficult to capture at the source code level due to their delocalized nature.
Changing program source code is one of the most tedious tasks faced by a programmer. However, if it were possible to express these operations at a level above traditional text-based editing, the programmers would both be more efficient and make fewer errors. This research focuses on the problem of programmers' expression and interaction with a programming tool. We combine the results from psychology of programming, user-interface design, software visualization, program analysis, and program transformation fields to create a novel programming environment that lets the programmer describe a source code manipulation, such as adding a parameter to a procedure, in a "natural" manner.
Our approach is to first study and understand how programmers form mental "update plans" for changing source code. The results of this study will be used to design a tool that makes it easy to specify and execute source code transformations. This tool will utilize the analysis capabilities of Harmonia, a program analysis framework for building language-based tools, and will be embedded in Eclipse, an existing full-featured IDE. The resulting prototype will be evaluated both through an existing cognitive framework as well as through deployment to a user community.