About George Fairbanks

I have the full stack of BS, MS, and PhD computer science degrees, with the last one from Carnegie Mellon University's software engineering PhD program. I was enormously fortunate to be advised by David Garlan and Bill Scherlis, with Jonathan Aldrich and Ralph Johnson on my thesis committee. My research focused on design fragments, a new way to specify and assure the correct use of frameworks.

Outside of academics, I have experience doing the following:

  • architecting systems for large financial firms
  • teaching architecture and software design
  • mentoring developers / management on software architecture and design
  • building software in large and small teams
  • running a web startup

Please see the website for Rhino Research, my new software architecture company for details on what I'm up to professionally. The company focuses on software architecture training and software architecture consulting.

I have written a book on software architecture that has been reviewed well. It's available on Amazon (e-book too) and several chapters are available free for download.

Contact information
George Fairbanks
Phone: (303) 834-7760
Email: gf-web@georgefairbanks.com
Mail: 124 W 60th St Apt 37L, New York, NY 10023

Software Architecture Book

I have written a book on software architecture and have posted several chapters on my company’s website.

Software Architecture Publications

Software architecture experience report

System builders have historically used informal software architecture models to understand options, make choices, and communicate with others. Research into software architecture over the past fifteen years has indicated that more precise architecture models may be beneficial. At a large financial firm, we applied precise software architecture techniques on four software projects and this experience has revealed a number of practical issues. We made the following observations across the projects:

  1. Architecture models can be used to bridge gaps between business requirements and technology
  2. A small collection of techniques and a detail knob are practical and useful in a variety of projects
  3. Architecture modeling techniques amplify the skills of the architects
  4. A model of domain concepts and relationships is helpful when building architecture models
  5. It is difficult to know when to stop adding detail to your architecture model

We believe that these observations motivate future research and can help practitioners make software architecture more effective in practice.

George Fairbanks, Kevin Bierhoff and Desmond D'Souza. Software Architecture at a Large Financial Firm. In Proceedings of ACM SIGPLAN Conference on Object Oriented Programs, Systems, Languages, and Applications (OOPSLA) 2006, Portland, OR, USA, 22-27 October 2006. CMU hosted copy bibtex

Organization and teaching issues with software architecture

A large financial company, struggling with legacy systems that did not interoperate, performed a pilot project to teach software architecture to an enthusiastic application development team. Experienced mentors, including the author, worked with the application team for seven months who completed their engineering goal successfully. However, the mentors were unsuccessful in their attempt to train any of the six members of application team to create architecture models on their own, though they were able to create them collaboratively with the mentors. This surprising result is due to the application team's strong preference for concrete artifacts over abstract ones. Even more surprising, an application developer from a different project, 'Developer X', read the architecture modeling documentation on an internal website and, without mentoring, created good architecture models within a few days. In light of this failure to teach software architecture, two short-term strategies are suggested for the use of software architecture in companies and long-term strategies are discussed.

George Fairbanks. Why Can't They Create Architecture Models Like Developer X? An Experience Report. In The 2003 International Conference on Software Engineering (ICSE'03), Portland, OR, 3-10 May 2003. CMU hosted copy bibtex

Design Fragments Publications

My research at CMU focused on design fragments, a new way to specify and assure the correct use of frameworks.

Presentation on Design Fragments at the University of Colorado Boulder

Presentation on Design Fragments at the University of Colorado Boulder.

Design Fragments (Thesis)

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 external files.

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.

The thesis of this dissertation is: We can provide pragmatic help for programmers to use frameworks by providing a form of specification, called a design fragment, to describe how a client program can correctly employ a framework and by providing tools to assure conformance between the client program and the design fragments.

We built tools into an IDE to demonstrate how design fragments could alleviate the difficulties experienced by client programmers. We performed two case studies on commercial Java frameworks, using demo client programs from the framework authors, and client programs we found on the internet. The first case study, on the Applet framework, yielded a complete catalog of twelve design fragments based on our analysis of fifty-six Applets. The second case study, on the larger Eclipse framework, yielded a partial catalog of fourteen design fragments based on our analysis of more than fifty client programs.

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.

Design Fragments thesis by George Fairbanks
CMU hosted copy of thesis

Design fragments technical paper

Object oriented frameworks impose new burdens on programmers that libraries did not, such as requiring the programmer to understand the method callback sequence, respecting behavior constraints within these methods, and devising solutions within a constrained solution space. To overcome these burdens, we express the repeated patterns of engagement with the framework as a design fragment. We analyzed the 20 demo applets provided by Sun and created a representative catalog of design fragments of conventional best practice. By evaluating 36 applets pulled from the internet we show that these design fragments are common, many applets copied the structure of the Sun demos, and that creation of a catalog of design fragments is practical. Design fragments give programmers immediate benefit through tool-based conformance assurance and long-term benefit through expression of design intent.

George Fairbanks, William Scherlis and David Garlan. Design Fragments Make Using Frameworks Easier. In Proceedings of ACM SIGPLAN Conference on Object Oriented Programs, Systems, Languages, and Applications (OOPSLA) 2006, Portland, OR, USA, 22-27 October 2006. CMU hosted copy bibtex

Early design fragments position paper

Modern software engineering environments provide programmers with contextual information on methods and classes in their software system. However, programmers increasingly encounter frameworks such as Microsoft Foundation Classes or Enterprise Java Beans whose required plug-in mechanisms cannot be adequately described with method or class documentation. The needs of programmers using frameworks are different from the needs when using libraries. Software engineering environments should be augmented with tools to aid programmers in understanding the demands of using frameworks.

George Fairbanks. *Software Engineering Environment Support for Frameworks: A Position Paper*. In Proceedings of the ICSE 2004 Workshop on Directions in Software Engineering Environments, Edinburgh, Scotland, May 2004.
CMU hosted copy bibtex

Defense talk on design fragments

These slides were used during my thesis defense. Design fragments thesis presentation

OOPSLA 2006 Poster

This poster won first place in the ACM Student Research Competition at OOPSLA 2006. Design fragments poster

CyLab 2007 Poster

This is a smaller version of the OOPSLA poster, but contains the results of our Eclipse case study. It was presented at the CyLab meeting in May 2007. Design fragments poster 2

Syndicate content