Department of Computer Science

Laboratory for Software Design

The research and educational activities described on these pages has been supported in part by the US National Science Foundation (NSF) under grants CCF-11-17937, CCF-10-17334, CNS-07-09217, CNS-06-27354, and a CAREER award 08-46059.

Got a question?

Got a question or comment? Contact us at (515) 294-6168 or

Active Research Projects


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.

[Onward!'10], [GPCE'10], [FoSER'10], [OOPSLA'10 Poster], [OOPSLA'10 Poster]


Ultra-large-scale software repositories (e.g., SourceForge, GitHub, Google Code) contain an enormous corpus of software and related information about software projects. Systematic extraction of relevant data from these repositories and analysis of such data for testing hypotheses is hard, and best left for mining software repository (MSR) experts. The goal of Boa, a domain-specific language and infrastructure, is to ease testing MSR-related hypotheses.

[ICSE'14], [ICSE'13], [ASE'13], [GPCE'13], [SPLASH'13 (SRC)], [SPLASH'12 (Poster)]


A software is created to satisfy user needs (also called concerns). These concerns may change often and unanticipatedly. On a concern change, the parts of the software called modules, responsible for that concern must also be revised. A module revision incurs costs and may introduce new errors. It is thus desirable to minimize module revisions. Some concerns, called crosscutting concerns e.g. security, fault tolerance, accountability, etc; have systemic effect. If many modules are responsible for such a concern, a change in it could trigger costly and error-prone systemic module revisions. We are designing the Ptolemy language to help avert these systemic revisions.

[TAOSD'13], [AOSD'12], [FOAL'12], [AOSD'11], [FOAL'10], [TOSEM '09], [ECOOP '08], [IEEE Software '06], [ESEC/FSE '05]


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.

[CGO '11], [RTSS '10], [PLOS '07], [IW-MSE '09]


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.

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

Past Research Projects


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 Frances project produces tools for teaching topics related to code generation and mapping high-level languages to low-level langages. First, Frances is designed to help teach code generation and assembly language. Second, Frances-A is designed to help teach computer architecture, assembly language, and how high-level code actually executes on a system.

[SIGCSE '10], [CCSC '11], [CCSC '10]


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.

[FASE'11], [TOSEM'09], [AOSD'08], [VMIL '08], [VMIL '07], [FSE '06(Poster)], [SPLAT '06]


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]


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.