Laboratory for Software Design

Ptolemy is a language design that combines best ideas from aspect-oriented languages and implicit invocation languages. The key notion is that of quantified, typed events. Quantified, typed events are interfaces that serve to mutually decouple subjects and observers, allow type-based quantification over events in the program without introducing dependence, and support flexible context exposure. Ptolemy's design builds upon our previous work on crosscutting programming interfaces (XPIs).

[ECOOP '08], [TOSEM '09], [IEEE Software '06], [ESEC/FSE '05]

Eos is a unified aspect-oriented extension for C# on Microsoft® .NET Framework™. Eos unifies aspects and objects as classpects. The unified language model improves the conceptual integrity of the language design and the compositionality of aspect modules to better support hierarchical advising structures.

[TOSEM '08], [PLOP '07], [ICSE '05], [AOSD '05], [ICSE '04 - DS], [ESEC/FSE '03]

The Nu (pronounced new) project is exploring intermediate language design and corresponding virtual machine extensions to better support new features of aspect-oriented languages. The potential impacts of this project include better compatibility with the existing tool chain, better run-time performance, cross AO language compatibility, improved pointcut expressivity, efficient run-time weaving support, etc.

[VMIL '08], [AOSD '08], [VMIL '07], [FSE '06 - Poster Paper], [SPLAT '06]

As multi-core processors are becoming common, vendors are starting to explore trade offs between the die size and the number of cores on a die, leading to heterogeneity among cores on a single chip. For efficient utilization of these processors, application threads must be assigned to cores such that the resource needs of a thread closely matches resource availability at the assigned core. Current methods of thread-to-core assignment often require an application's execution trace to determine it's runtime properties. These traces are obtained by running the application on some representative input. A problem is that developing these representative input sets is time consuming, and requires expertise that the user of a general-purpose processor may not have. In this project, we are designing, implementing and evaluating automatic thread-to-core assignment techniques for heterogeneous multi-core processors that will enhance the utilization of these processors.

[PLOS '07], [IW-MSE '09]

The key notion in service-oriented architecture is decoupling clients and providers of a service based on an abstract service description, which is used by the service broker to point clients to a suitable service implementation. A client then sends service requests directly to the service implementation. A problem with the current architecture is that it does not provide trustworthy means for clients to specify, service brokers to verify, and service implementations to prove that certain desired non-functional properties are satisfied during service request processing. An example of such non-functional property is access and persistence restrictions on the data received as part of the service requests. In this project, we are developing an extension of the service-oriented architecture that provides these facilities. We are also developing a prototype implementation of this architecture that demonstrate the potential practical value of the proposed architecture in real-world software applications.

[ESOP '09], [IEEE SOC '08], [NWeSP '07], [IW-SOSWE '07]

The Slede project is looking at specification language design and supporting verification mechanisms for specifying and verifying cryptographic protocols for sensor networks. Applications of sensor networks are numerous from military to environmental research. By providing mechanisms to find cryptographic errors in the security protocols for sensor networks this research program is improving the reliability of these networks, making a direct impact on all areas where these networks are utilized.

[WiSec '08], [ESEC/FSE '07 - DS], [FSE '06 - Poster paper]

Writing correct and efficient concurrent programs still remains a challenge. Explicit concurrency is difficult, error prone, and creates code which is hard to maintain and debug. This type of concurrency also treats modular program design and concurrency as separate goals, where modularity often suffers. To solve these problems, we are designing a new language that we call Panini. Panini's goals are to reconcile the modularity goals promoted by good software design practices with the concurrency goals of exposing potential concurrency between the execution of components. Since modularity is improved and concurrency is implicit in Panini, programs are easy to reason about and maintain. Furthermore, races and deadlocks are avoided entirely yielding programs with a guaranteed sequential semantics.

[TR'10],

Comprehending software is hard. As system complexity and size increases, existing approaches for program comprehension become less usable. Ironically, the need for these approaches increases with the size of the system. In the Osiris project, we are looking at approaches and tools for automatic/semi-automatic generation of concerns models from source code for better comprehension of large software systems.