Our ability to build complex software systems relies on composition techniques and programming language mechanisms that enable us to construct complete programs from smaller pieces. A particular decomposition imposes a structure that makes it possible to manage the complexity of a large system, provided that each component can be developed and maintained with some degree of independence, and that each feature can be localized in one or two components. Unfortunately, the same decomposition makes it harder to add or change features that cut across that structure.

We believe that the design, evolution, maintenance, and comprehension of software can be better supported by tools that allow programmers to examine and work with multiple perspectives on a program instead of constraining them to a single decomposition. That is, programmers should be empowered to think of programs not as linear texts but as equivalence classes of concrete views, each of which is useful for certain tasks, but none of which is more definitive than any other.

These are the problems that we are tackling in the Multiview project at PSU. Our work to date has been focused in three areas

• The search for new, high-level representations of program source code—which we refer to as an "abstract program structure" or APS—that is able to capture program semantics fully while simultaneously abstracting away from specific details of syntax and physical structure. Instead, common representations of a program—such as the one or two dimensional syntax of a linear source text, the underlying abstract syntax trees, or the class diagrams that describe its architecture—should be obtained as different views on a rich APS.
• The design and implementation of a practical tool called Sweet that permits considerably more flexible decomposition and construction of Java programs than do conventional Java compilers. In the input to Sweet, a programmer blends definitions of parts of the program structure, for example, a packages, class heirarchies, or methods, with descriptions of the executable content that should be placed within that structure.
• Diverse interfaces for improved program analysis tools, especially for semi-automatic refactoring. We observe how programmers perform tasks to determine how and when what view should be used when interacting with program analysis tools.
  
• The integration and experimentation with these ideas in the context of a practical, interactive development system. This work is based on the Eclipse IDE.

You can find our publications here.

This material is based upon work supported by the National Science Foundation under Grant No. 0520346. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of the National Science Foundation.