Research Areas - Software Engineering Research in the Computer Science Department at Carnegie Mellon
Software engineering is the branch of computer science that creates practical, cost-effective solutions to computing and information processing problems, preferentially by applying scientific knowledge, developing software systems in the service of mankind. Software engineering entails making decisions under constraints of limited time, knowledge, and resources. The distinctive character of software raises special issues about its engineering. These characteristics and issues include:
Software engineering rests on three principal intellectual foundations. The technical foundation is a body of core computer science concepts relating to data structures, algorithms, programming languages and their semantics, analysis, computability, computational models, etc.; this is the core content of the discipline. This technical knowledge is applied through a body of engineering knowledge related to architecture, the process of engineering, tradeoffs and costs, conventionalization and standards, quality and assurance, etc.; this provides the approach to design and problem solving that respects the pragmatic issues of the applications. These are complemented by the social and economic context of the engineering effort, which includes the process of creating and evolving artifacts, as well as issues related to policy, markets, usability, and socio-economic impacts; this provides a basis for shaping the engineered artifacts to be fit for their intended use.
Software engineering research is concerned with improving our ability to systematically and predictably analyze and develop sophisticated software that must satisfy complex, ill-specified requirements and that must evolve during its lifetime. Software engineering results often take the form of methods for development and analysis; they may also be new or improved models or theories. Software engineering results may be established qualitatively, through empirical study of software systems, through empirical study of the software development process, or through formal analysis.
1 Carnegie Mellon Focus
At Carnegie Mellon, research in software engineering is performed primarily in the School of Computer Science, chiefly the Institute for Software Research International and the Computer Science Department, with additional contributions from other parts of the University such as Electrical and Computer Engineering and the Software Engineering Institute. We focus here on the portion of this research that involves members of CSD, but it is important to bear in mind that this is part of a larger enterprise, and the enterprise as a whole is more balanced and comprehensive than this slice.
CSD faculty research interests in software engineering is principally of two kinds: developing improved models and techniques for the design and implementation of large complex software systems that must satisfy rich, often under-specified, requirements in their operating environments, and developing improved models and techniques for formal analysis of software components to assure or determine specific formalizable properties.
The precursors of software engineering research in CSD included work in the 1970s on abstract data types with formal specifications, work in the 1980s on software development environments, work beginning in the 1980s on program analysis and the application of formal methods to practical problems. Drawing on these results, current research in the Computer Science Department addresses software architecture (Garlan, Schmerl, Shaw), self-healing systems (Garlan, Schmerl), value-based design analysis (Shaw), security (Clarke, Garlan, Wing), and programming language design in support of program analysis (ISRI faculty Aldrich and Scherlis, in collaboration with the principles of programming faculty). Virtually all of this work is collaborative with faculty and students in ISRI, HCII, SEI, Heinz, and other units of the university; additionally, much of it involves collaborations outside the University.
2 Research Thrusts
Software architecture Over the past decade the architectural design of software has emerged as a critical success factor complex software systems development. But until recently architectural design has been largely based on ad hoc choice, informal experience, and local expertise. Our research at Carnegie Mellon has focused on ways to make this knowledge precise, codified, and available to engineers as a matter of routine engineering. This has resulted in the development of several architecture description languages (including Wright, UniCon, and Acme), as well as tools to support the analysis of architectural designs and generation of systems from architectural blueprints. On-going research seeks to transition these results to industry through case studies (e.g., with NASA JPL), explore sophisticated design analysis (e.g., using model checking, simulation, and various analytical models), and augment our ability to maintain correspondence between an architectural design and its implementation (e.g., through code generation and run-time monitoring).
Self-healing systems Systems of the future must take more responsibility for their own health and welfare. Today self-monitoring and self-adaptation of systems (if it exists at all) is handled in an ad hoc manner, and embedded in the application code itself. In the research at Carnegie Mellon we are developing a new approach in which monitoring and adaptation mechanisms are engineered externally from the application. “Externalization” permits one to cleanly separate concerns about normal operation from adaptive mechanisms, reason about adaptation policies independently of the adapted application, reuse adaptation infrastructure and strategies, and provide tools and mechanisms that greatly reduce the cost of adding adaptation to existing systems. The main idea behind this work is to use the architectural specification of a system at run time as the carrier of constraints on when and how a system should adapt dynamically. We are also looking at the application of economic theories to help aid in reconfiguration decisions in situations where resources are constrained.
Value-based design Traditional engineering design discipline calls for designs to be evaluated long before they are implemented and for designs to be evaluated in terms of their overall value to the client, including costs and contextual considerations as well as capability. This area of research is focused on bringing these aspects of engineering practice to software engineering by developing a framework for evaluating early-stage designs to predict the value a user will see in an implementation.. Early design evaluations predict properties of the artifact that will result from a proper implementation of the design; the predicted properties can include costs as well as functionality, performance, and quality measures. Software engineering has some such evaluation techniques. However, we lack predictors for many properties of interest, and we lack a systematic way to explain, compare, develop, and apply them. Current research in value-based design analysis draws on techniques from economics as well as computer science to develop new predictors. We are especially interested in techniques that predict properties of the finished software system before the expense of software development is incurred. Our longer-term objective is to develop a unifying model for design evaluation techniques. Even in its preliminary state, our framework is sufficiently expressive to be useful in explaining and characterizing design evaluation techniques.
Software engineering at Carnegie Mellon is distinguished by our blend of formal analysis with engineering and economics. In addition, we are among the research groups that have moved beyond the traditional focus on large monolithic software to address the problems of dependability and interactions among independent systems that have emerged with the Internet and the pervasive embedding of software in human systems.
We have the leading group in software architecture (Garlan, Shaw, along with SEI), including founders of the subdiscipline. This group produced one of the first serious books in software architecture, which is still selling despite its age. A more recent book on documenting software architectures was selected for a Productivity Award in the category “Books, Practical/General Developer Interest” in the 2003 annual Jolt awards. Members of this group are on the steering committee of the principal software architecture conference and the international IFIP Working Group on Software Architecture.
A common complaint in software engineering research is difficulty in obtaining access to data on real systems and real software development processes. We have been largely successful in overcoming the difficulties associated with access to real data, so we are able to develop and evaluate our theories in concrete and credible ways.
We also have strong collaborative and interdisciplinary connections: to ISRI not only for software engineering but also for policy and business concerns; to SEI for industrial connections and transfer of ideas from research to adoption; to CyLab for security work; and to Heinz through the Sloan Software Industry Center.
The principal highly-selective conference in software engineering is the International Conference on Software Engineering (ICSE). Each ICSE conference makes a retrospective award for the “most influential” paper from the 10th-previous ICSE conference. Of the 17 such awards over the years, two have been made to current faculty and four more have been made to former Carnegie Mellon students and faculty. In the three most recent ICSE conferences, about 7% of the refereed technical presentations have come from Carnegie Mellon.
We, like many engineering-oriented software engineering groups, suffer from a widespread public misperception that confuses software engineering with mere programming or with software management. Both comparisons are inappropriate, as the responsibilities of an engineer include the deliberate, collaborative creation and evolution of software-intensive systems that satisfies a wide range of technical, business, and regulatory requirements. Software engineering is not simply the implementation of application functionality, nor is it simply the ability to manage a project in an orderly, predictable fashion.
Software dependability differs from dependability in most other areas because in software engineering we are concerned with design flaws, integration surprises, and problems that arise from our imperfect understanding of the software. Classical reliability problems such as manufacturing variability, fatigue failures, and wear-out from use play a very small part for software. But in exchange for not having to worry about instance failure, we get a problem on the other end, namely that software is often much more general than physical products, so we gain the opportunity to lose dependability because the designer didn’t fully understand the range of applications. For software, dependability is no longer a problem of systems in isolation, if it ever was. Dependability problems now arise from interactions among systems, from the operating system monoculture that allows design flaws to be exploited on a worldwide scale, and from the inscrutability of computing systems to their users.
Companies in many industries are recognizing that they depend critically on software development, not only to run the business but also to incorporate in their products. Companies tell us, “We used to think that we’re in such-and-such a business, but we’re coming to realize that software development dominates our activity.” Moreover, the ubiquitous information infrastructure has created joint dependencies on software that raise the stakes for dependable software. Thus companies realize that they need better software development practices, and they turn to Carnegie Mellon for help.
|CSD Home Webteam ^ Top SCS Home|