Publications
The following is a list of my research publications. Where possible, I try to make them available for download.
- Software Architecture: Foundations, Theory, and Practice
- Supporting Stakeholder-driven, Multi-view Software Architecture Modeling
- Moving Architectural Description from Under the Technology Lamppost
- A Comprehensive Approach for the Development of Modular Software Architecture Description Languages
- An Approach for Tracing and Understanding Asynchronous Architectures
- The Role of Middleware in Architecture-Based Software Development
- Towards Architecture-based Self-healing Systems
- An Infrastructure for the Rapid Development of XML-based Architecture Description Languages
- Using Off-The-Shelf Middleware to Implement Connectors in Distributed Software Architectures
- Issues in Generating Data Bindings for an XML Schema-Based Language
- A Highly-Extensible, XML-Based Architecture Description Language
- Representing Product Family Architectures in an Extensible Architecture Description Language
Software Architecture: Foundations, Theory, and Practice
Richard N. Taylor, Nenad Medvidovic, and Eric M. Dashofy
Available now from John Wiley and Sons. ISBN: 978-0470167748.
This is our full-length textbook on software architecture.
Rather than focus on one method, notation, tool, or process, this book attempts to widely survey software development from an architectural perspective. It provides a technical view of software architecture. Insights in this book will enable better understanding of the unique issues involved in the development of large software systems. Software architects or systems engineers should expect to gain a broad appreciation for the role of software architecture across the wide variety of activities that characterize the development of large, software-intensive systems.
- Software Architecture: Foundations, Theory, and Practice at Wiley.com, our publisher’s site
- Software Architecture: Foundations, Theory, and Practice at Amazon.com
- Software Architecture: Foundations, Theory, and Practice at Barnes and Noble
Supporting Stakeholder-driven, Multi-view Software Architecture Modeling
Eric M. Dashofy
Ph.D. Dissertation, University of California, Irvine. 2007.
Abstract
A software system’s architecture can be seen as the set of principal design decisions about that system. These design decisions can be captured in architectural models. Existing approaches to architecture modeling support general concerns well, but are difficult or impossible to adapt to new concerns or domains. This research examines how to support stakeholder-driven architecture modeling: modeling in a world where the system’s stakeholders materially participate in deciding what kinds of design decisions will be modeled and at what level of detail, as well as how they will be visualized, analyzed, and applied in other development activities. Contributions include a highly-extensible language (xADL) and environment (ArchStudio) for stakeholder-driven architecture modeling, a demonstration that many architectural concerns can be modularized within this environment, and a set of design principles that guide and inform the construction of the environment. Application and use of the environment in a variety of domains and projects demonstrates its effectiveness, and evidence indicates that the amount of effort needed to develop extensions to the environment scales with the conceptual complexity of those extensions.
Moving Architectural Description from Under the Technology Lamppost
Nenad Medvidovic, Eric M. Dashofy, and Richard N. Taylor
In Information and Software Technology 49(1), January 2007. p. 12-31.
Abstract
Software architecture description languages (ADLs) were a particularly active research area in the 1990s. In 2000, we published an extensive study of existing ADLs, which has served as a useful reference to software architecture researchers and practitioners. However, the field of software architecture and our understanding of it have undergone numerous changes in the past several years. In particular, the Unified Modeling Language (UML) has gained popularity and wide adoption, and as a result many of the ADLs we had studied have been pushed into obscurity. In this paper, we argue that the main reason behind this is that the early ADLs focused almost exclusively on the technological aspects of architecture, and mostly ignored the application domain and business contexts within which software systems, and development organizations, exist. Together, these three concerns-technology, domain, and business-constitute the three “lampposts” needed to appropriately “illuminate” software architecture and architectural description. We use this new framework to evaluate both the languages from our original study, as well as several more recent ADLs (including UML 2.0).
A Comprehensive Approach for the Development of Modular Software Architecture Description Languages
Eric M. Dashofy, André van der Hoek, and Richard N. Taylor
In ACM Transactions on Software Engineering and Methodology (TOSEM), 14(2), April 2005, pp. 199-245
Abstract
Research over the past decade has revealed that modeling software architecture at the level of components and connectors is useful in a growing variety of contexts. This has led to the development of a plethora of notations for representing software architectures, each focusing on different aspects of the systems being modeled. In general, these notations have been developed without regard to reuse or extension. This makes the effort in adapting an existing notation to a new purpose commensurate with developing a new notation from scratch. To address this problem, we have developed an approach that allows for the rapid construction of new architecture description languages (ADLs). Our approach is unique because it encapsulates ADL features in modules that are composed to form ADLs. We achieve this by leveraging the extension mechanisms provided by XML and XML schemas. We have defined a set of generic, reusable ADL modules called xADL 2.0, useful as an ADL by itself, but also extensible to support new applications and domains. To support this extensibility, we have developed a set of reflective syntax-based tools that adapt to language changes automatically, as well as several semantically-aware tools that provide support for advanced features of xADL 2.0. We demonstrate the effectiveness, scalability, and flexibility of our approach through a diverse set of experiences. First, our approach has been applied in industrial contexts, modeling software architectures for aircraft software and spacecraft systems. Second, we show how xADL 2.0 can be extended to support the modeling features found in two different representations for modeling product-line architectures. Finally, we show how our infrastructure has been used to support its own development. The technical contribution of our infrastructure is augmented by several research contributions: the first decomposition of an architecture description language into modules, insights about how to develop new language modules and a process for integrating them, and insights about the roles of different kinds of tools in a modular ADL-based infrastructure.
An Approach for Tracing and Understanding Asynchronous Architectures
Scott A. Hendrickson, Eric M. Dashofy, and Richard N. Taylor
In Proceedingds of the 18th IEEE International Conference on Automated Software Engineering (ASE 2003). Oct. 6-10, 2003. p. 318-322
Applications built in a strongly decoupled, eventbased interaction style have many commendable characteristics, including ease of dynamic configuration, accommodation of platform heterogeneity, and ease of distribution over a network. It is not always easy to humanly grasp the dynamic behavior of such applications, since many threads are active and events are asynchronously (and profusely) transmitted. We present a set of requirements for an aid to assist in the human understanding and exploration of the behavior of such applications through the incremental refinement of rules for determining causality relationships between messages sent among components. A prototype tool is presented, indicating one viable approach to meeting these requirements. Experience with the tool reinforces some of the requirements and indicates others.
The Role of Middleware in Architecture-Based Software Development
Nenad Medvidovic, Eric M. Dashofy, and Richard N. Taylor
In The International Journal of Software Engineering and Knowledge Engineering (IJSEKE), 13(4), 2003, pp. 367-393
Abstract
Software architectures promote development focused on modular functional building blocks (components), their interconnections (configurations), and their interactions (con- nectors). Since architecture-level components often contain complex functionality, it is reasonable to expect that their interactions will be complex as well. Middleware technolo- gies such as CORBA, COM, and RMI provide a set of predefined services for enabling component composition and interaction. However, the potential role of such services in the implementations of software architectures is not well understood. In practice, middleware can resolve various types of component heterogeneity | across platform and language boundaries, for instance | but also can induce unwanted architectural constraints on application development. We present an approach in which components communicate through architecture-level software connectors that are implemented using middleware. This approach preserves the properties of the architecture-level connectors while leveraging the beneficial capabilities of the underlying middleware. We have imple- mented this approach in the context of a component- and message-based architectural style called C2 and demonstrated its utility in the context of several diverse applications. We argue that our approach provides a systematic and reasonable way to bridge the gap between architecture-level connectors and implementation-level middleware packages.
Towards Architecture-based Self-healing Systems
Eric M. Dashofy, André van der Hoek, and Richard N. Taylor
In Proceedings of the 2002 Workshop on Self-Healing Systems (WOSS’02), pp. 21-26
Abstract
Our approach to creating self-healing systems is based on software architecture, where repairs are done at the level of a software system’s components and connectors. In our approach, event-based software architectures are targeted because they offer significant benefits for run-time adaptation. Before an automated planning agent can decide how to repair a self-healing system, a significant infrastructure must be in place to support making the planned repair. Specifically, the self-healing system must be built using a framework that allows for run-time adaptation, there must be a language in which to express the repair plan, and there must be a reconfiguration agent that can execute the repair plan once it is created. In this paper, we present tools and methods that implement these infrastructure elements in the context of an overall architecture-based vision for building self-healing systems. The paper concludes with a gap analysis of our current infrastructure vs. the overall vision, and our plans for fulfilling that vision.
An Infrastructure for the Rapid Development of XML-based Architecture Description Languages
Eric M. Dashofy, André van der Hoek, and Richard N. Taylor
In Proceedings of the 24th International Conference on Software Engineering (ICSE2002), Orlando, Florida.
Abstract
Research and experimentation in software architectures over the past decade have yielded a plethora of software architecture description languages (ADLs). Continuing innovation indicates that it is reasonable to expect more new ADLs, or at least ADL features. This research process is impeded by the difficulty and cost associated with developing new notations. An architect in need of a unique set of modeling features must either develop a new architecture description language from scratch or undertake the daunting task of modifying an existing language. In either case, it is unavoidable that a significant effort will be expended in building or adapting tools to support the language. To remedy this situation, we have developed an infrastructure for the rapid development of new architecture description languages. Key aspects of the infrastructure are its XML-based modular extension mechanism, its base set of reusable and customizable architectural modeling constructs, and its equally important set of flexible support tools. This paper introduces the infrastructure and demonstrates its value in the context of several real-world applications.
Using Off-The-Shelf Middleware to Implement Connectors in Distributed Software Architectures
Eric M. Dashofy, Nenad Medvidovic, and Richard N. Taylor
In Proceedings of the 21st International Conference on Software Engineering (ICSE’99), Los Angeles, CA.
Abstract
Software architectures promote development focused on modular building blocks and their interconnections. Since architecture-level components often contain complex functionality, it is reasonable to expect that their interactions will also be complex. Modeling and implementing software connectors thus becomes a key aspect of architecture-based development. Software interconnection and middleware technologies such as RMI, CORBA, ILU, and ActiveX provide a valuable service in building applications from components. The relation of such services to software connectors in the context of software architectures, however, is not well understood. To understand the tradeoffs among these technologies with respect to architectures, we have evaluated several off-the-shelf middleware technologies and identified key techniques for utilizing them in implementing software connectors. Our platform for investigation was C2, a component- and message-based architectural style. By encapsulating middleware functionality within software connectors, we have coupled C2’s existing benefits such as component interchangeability, substrate independence and structural guidance with new capabilities of multi-lingual, multi-process and distributed application development in a manner that is transparent to architects.
Issues in Generating Data Bindings for an XML Schema-Based Language
Eric M. Dashofy
In Proceedings of the Workshop on XML Technologies and Software Engineering (XSE2001), Toronto, ONT, Canada.
Abstract
XML’s meta-language aspect and extensive tool support make it an attractive way to build modularly extensible modeling languages. XML’s original meta-language, the document type definition (DTD), is being replaced by the more expressive XML schema. Developing programmatic tools to manipulate models specified in XML schemas is made easier though the use of data bindings. Data bindings model elements and attributes in XML schemas as objects in an object-oriented programming language. We have developed an XML-schema aware generator for Java data bindings called ‘apigen’. While developing apigen, we encountered and worked through several issues, both essential and accidental, related to generating XML schema data bindings. These issues, and the solutions we developed, are described in this paper.
A Highly-Extensible, XML-Based Architecture Description Language
Eric M. Dashofy, André van der Hoek, and Richard N. Taylor
In Proceedings of the Working IEEE/IFIP Conference on Software Architectures (WICSA 2001), Amsterdam, Netherlands.
Abstract
Software architecture research focuses on models of software architectures as specified in architecture description languages (ADLs). As research progresses in specific areas of software architectures, more and more architectural information is created. Ideally, this information can be stored in the model. An extensible modeling language is crucial to experimenting with and building tools for novel modeling constructs that arise from evolving research. Traditional ADLs typically support a small set of modeling constructs very well, but adapt to others poorly. XML provides an ideal platform upon which to develop an extensible modeling language for software architectures. Previous XML-based ADLs successfully leveraged XML’s large base of off-the-shelf tool support, but did not take advantage of its extensibility. To give software architecture researchers more freedom to explore new possibilities and modeling techniques while maximizing reuse of tools and modeling constructs, we have developed xADL 2.0, a highly extensible XML-based ADL. xADL 2.0 supports run-time and design time modeling, architecture configuration management, and model-based system instantiation. Additionally, xADL 2.0 has a set of extensible infrastructure tools that support the creation, manipulation, and sharing of xADL 2.0 documents.
Representing Product Family Architectures in an Extensible Architecture Description Language
Eric M. Dashofy and André van der Hoek
In Proceedings of the International Workshop on Product Family Engineering (PFE-4), Bilbao, Spain, October 2001.
Abstract
Product family architectures need to be captured much like “regular” software architectures. Unfortunately, representations for product family architectures are scarce and a deep understanding of all of the necessary features of such representations is still lacking. In this paper, we introduce an extensible XML-based representation that is suitable as a basis for rapidly defining new representations for product family architectures. We describe some of the details of this representation and present how Koala and Mae, two early representations for product family architectures, can be mapped onto our XML-based representation with relatively little effort.
