Course: Sofware Design

Goal: Provide developers with the design concepts and techniques necessary to build modules and components.


This class provides working developers with a survey of software engineering knowledge and techniques that are relevant for day-to-day software development. They learn about encapsulation, including how to apply Design by Contract, why encapsulation works and how it can fall short, and how to use encapsulation metrics like coupling and cohesion.

Every developer needs to understand the basics of software processes. The class covers Brooks’ observations in the Mythical Man Month and surveys processes including waterfall, spiral, and agile methods like XP and Scrum.

Languages have a big impact on a developer’s life and systems. The class covers how language ideas have changed and features such as structured programming, typing, and abstract data types. Current options like code generation and model driven engineering are evaluated, exposing their strengths and limits.

For better or for worse, it is easy to program using an old style in an object oriented (OO) language, so many developers have made the switch to a new language but have not yet learned how to take advantage of objects. OO developers should live and breathe design patterns, be able to read and sketch out designs using UML, and know the difference between a library and a framework. They should have internalized Larman’s GRASP responsibility allocation patterns for effective OO design, and know when to bend the rules, as in Jacobson’s object types.

While this class focuses on how to design modules and components, these parts fit into the larger architecture of the system, so the class covers the distinction between them, including the new challenges that arise with programming in the large.

Detailed topic list:

  • Interfaces / encapsulation
    • Meyer’s Design by contract
    • Parnas’ encapsulation
    • Interfaces, provided and required
    • Coupling and cohesion, metrics
  • Process
    • Brooks’ Mythical Man Month
    • Waterfall, spiral, XP, agile, scrum, etc.
  • Languages
    • Dijkstra’s Goto Considered Harmful
    • Abstract Data Types (ADTs)
    • Type systems, strong and weak typing
    • Static analysis
    • Procedural, object, functional, etc. programming
    • Code generation
    • 4th Generation Languages
    • Model Driven Engineering and MDA
  • Object technology
    • UML
    • Design patterns
    • Frameworks
    • Object oriented design
    • Larman’s GRASP patterns
    • Domain Driven Design and model-code alignment
    • Jacobson’s object types
    • Object-relational mapping and impedance mismatch
  • Design and architecture
    • Design vs. architecture
    • Programming in the large vs. small
    • Service Oriented Architectures
    • Databases

We can reconfigure this course to include some alternate topics at the client’s request.


This course is suitable for software developers, especially those that have come to software engineering from another field or whose software engineering education was limited. Because of the need to track individual progress on a few exercises during the course, the maximum class size is 20.


This presentation is delivered by Dr. George Fairbanks. George has been teaching software architecture and object-oriented design since 1998, and in the Spring of 2008 he was the co-instructor for the graduate software architecture course at Carnegie Mellon University. He holds a Ph.D. in Software Engineering from Carnegie Mellon University, advised by David Garlan and Bill Scherlis. His dissertation introduced design fragments, a new way to specify and assure the correct use of frameworks through static analysis. He has publications on frameworks and software architecture in selective academic conferences. He has written production code for telephone switches, plugins for the Eclipse IDE, and everything from soup to nuts for his dot-com startup, and 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).

Logistics and Cost

This is a 3-day class.

On-site: This course is normally taught on-site with the customer. The cost is $1750 per person, with a minimum of five students, plus the instructor’s travel, room, and board expenses. Discounts apply for larger groups.

Public: Although this course is not normally offered on a public schedule, we will schedule one if there is demand. Email us to get on the waiting list.

Participants receive a copy of the lecture slides and exercises.



Related courses

Why Rhino Research?

Rhino Research is devoted to improving the state of software practice. We do this by using our industrial and academic roots to give you the freshest and most practical advice in classes and during consulting engagements.

Our clients

We have taught classes for many kinds of clients, ranging from regular information technology shops, to huge internet shops, to NASA.

Just Enough Software Architure Book

Available as an e-book ($9.99) or a hardback.

Get it on Google Play

Get it on Amazon


subscribe via RSS


Rhino Research is a training and consulting company specializing in software architecture

124 W 60th St #37L
New York, NY 10023