Our research activity in this area is directed at improving all aspects of software development, and at making software itself more efficient and reliable. We are addressing several facets of this problem, including: the creation of new programming paradigms and methodologies, the design of new programming languages, new implementation technologies for programming languages, sophisticated programming tools and superior programming environments, and the foundational aspects of this area.

Design Patterns

The most powerful form of reuse is not code reuse but design reuse. A proven piece of code is less likely to be reusable than a proven design, but a proven design is usually more difficult to develop. Design patterns promote design reuse by capturing and expounding proven object-oriented designs. A design pattern characterizes a single problem and its solution, the consequences of that solution, and variations on the solution's implementation. Our interests in this area include mining existing software for patterns, studying pattern application in all phases of development, and devising tools that support pattern perusal and automate their application.

Programming Paradigms

Limitations in the expressive power of existing languages and programming paradigms (such as object oriented programming) can get in the way of writing software in a form that is most natural and convenient. We are exploring new programming paradigms and language features that increase the expressiveness of languages. Our ongoing work on supporting multidimensional separation of concerns using hyperspaces is an example. Software modularization - the separation of software into components that implement independent concerns - is highly desirable. Unfortunately, software can usually be modularized in only one way (i. e., by class), which facilitates some development activities, but impedes others. The hyperspaces approach builds on our earlier work on subject-oriented programming to allow modularization according to multiple kinds of concerns simultaneously.

Language Design

Software development and maintenance are complex partly because of the large gap that exists between the conceptual view of a software system and its actual implementation. We are interested in reducing this gap by raising the level at which software design and development are done. As an example, we are developing novel concepts and languages for the high-level specification, programming, and evolution of business information systems. We are building system envisioning tools that allow users to experience and iterate upon a cheap mock-up of the system they have specified. We are also exploring the generation and evolution of real, production-strength applications from these same specification languages, built upon and generating new requirements for existing and emerging middleware technologies.

Language Implementation and Optimizing Compilers

New languages and language features need efficient implementations to succeed. Over the years, IBM Research has made significant contributions to this area, starting with the pioneering work of Fran Allen and John Cocke, which laid the foundations for the field of optimizing compilers. Currently, we are pursuing several lines of research, with a significant focus on Java. This includes work on just-in-time compilers, mixed-mode interpreters, dynamic compilers and virtual machines. Dynamic compilation, for example, enables new optimizations that exploit run-time information, while demanding more efficient and innovative solutions to old problems. Our other interests in this area include memory management and garbage collection, efficient implementation of concurrency and synchronization, and issues in application development for embedded systems. Fundamental algorithms and data structures relevant to the implementation of languages and tools, continue to be an area of our focus.

Tools and Environments

We believe that there is scope for programming tools much more powerful than programmers can imagine today - tools that can significantly improve programmer productivity. We are interested in static tools, which utilize semantic analysis to compute information about a program's possible execution behavior to help programmers understand programs, as well as in dynamic tools, which record information about a program's execution and use this information to help programmers understand, debug and tune programs. Some examples of our current interests include program visualization, program slicing, tools for collaborative program development, deterministic replay of multithreaded programs, and XML processing.

Software Defect Analysis and Other Tools

The orthogonal defect classification (ODC) methodology for analyzing software defects, an inexpensive way to evaluate process and product during development and maintenance, can improve software quality and development efficiency. We have an ongoing effort in ODC-related modeling and tools. We are also working on algorithms and tools for software testing and verification, such as combinatorial optimization for test design, model-driven automatic test generation, and the use of specification and assertion languages for test automation as well as verification.

Please contact Paridhi Verma to obtain copies of the Computer Science Brochure