Frameworks are a valuable way to share designs and implementations on a large
scale. Client programmers, however, have difficulty using frameworks. They find
it difficult to understand non-local client-framework interactions, design
solutions when they do not own the architectural skeleton, gain confidence that
they have engaged with the framework correctly, represent their successful
engagement with the framework in a way that can be shared with others, ensure
their design intent is expressed in their source code, and connect with
A design fragment is a specification of how a client program can use framework
resources to accomplish a goal. From the framework, it identifies the minimal
set of classes, interfaces, and methods that should be employed. For the client
program, it specifies the client-framework interactions that must be
implemented. The structure of the client program is specified as roles, where
the roles can be filled by an actual client s classes, fields, and methods.
A design fragment exists separately from client programs, and can be bound to
the client program via annotations in their source code. These annotations
express design intent; specifically, that it is the intention of the client
programs to interact with the framework as specified by the design fragment.
This work provides three primary contributions to software engineering. First,
it provides a new technique to help programmers use frameworks. Second, it
provides a systematic way to increase code quality. Design fragments provide a
means to communicate known-good designs to programmers, and, unlike simple
copying of examples, a means of influencing the uses of that design so that
revisions can be propagated. Third, it provides an empirically-based
understanding of how clients use frameworks, which aids researchers in choosing
research directions and aids framework authors in delivery of new frameworks.
George Fairbanks has been teaching software
architecture and object-oriented design for ten years for companies including
Kinetium, Valtech, and Platinum Technology. In the Spring of 2008 he was the
co-instructor for the graduate software architecture course at Carnegie Mellon
University. He holds a PhD in Software Engineering from Carnegie Mellon
University, advised by
David Garlan and William (Bill) Scherlis.
His dissertation introduced design fragments, a new way to specify and assure
the correct use of frameworks through static analysis.
He has written production code for telephone switches, plugins for the Eclipse
IDE, and everything for his own web dot-com startup. He maintains a network of
Linux servers in his spare time. George is a program committee member for
2009 Working International Conference on Software Architecture (WICSA 2009),
and has been a referee for IEEE Transactions on Software Engineering
(TSE). His book on
Risk-Centric Software Architecture
is due in Fall 2010 from Taylor & Francis.