Rhino Research

Master software architecture

Sat, 23 May 2015 00:00:00 -0400

The good news is that software design is no longer a black art and the field has consolidated on a set of shared ideas as its foundation. Temperament and aptitude help, but it is now possible to teach developers the essentials of architectural design. The bad news is that mainstream developers are just now starting to become aware of these ideas, yet the scale and complexity of systems has been steadily increasing year after year.

Here are some insights to our philosophy:

Risk-driven architecting. You can do just enough software architecture by focusing on risks and choosing corresponding design techniques. Your designs will vary in detail depending on how risky each area is for this project, perhaps deep on security but light on auditability.
Democratic approach. Our courses are for developers and architects. Architecture is a kind of software design that all developers should understand, not just architects.
Emphasis on engineering. Our courses are on how to design software, not on how to facilitate meetings. Soft skills are a compliment to design skills, not a substitute for engineering know-how.
Practical advice. You will learn techniques that work in practice and learn anti-patterns to watch out for.

Software Architecture and Design Courses at Rhino Research

Fri, 22 May 2015 00:00:00 -0400

Course participants will leave with a coherent mental framework of software architecture, helping them to reconcile business needs with implementation issues, identify risks, and successfully design systems.

Courses

We offer a set of interlocking classes designed to suit your needs. The shorter the course, the more general the intended audience. Combining the two 3-day architecture courses yields the same content as the 5-day marathon course. Splitting the training is recommended so that participants have an opportunity to try out the new techniques (and generate questions) before the advanced material.

Course	Length	% Lecture	Audience	Content
Dine and Discover	90 min	100%	Fully general	What and why of software architecture
Essence of Software Architecture	1 day	90%	Mostly general	Dine and Discover + a tour of how architecture is done
Software Architecture with UML	3 day	60%	Engineers	Essence of architecture + simplified how-to + exercises
Advanced Software Architecture	3 day	60%	Engineers	Adds realistic wrinkles + advanced techniques
Software Architecture Marathon	5 day	60%	Engineers	Combined Introduction + Advanced courses
Software Design	3 day	70%	Engineers	Module and component design (not architecture)

The lectures in the 3- and 5-day courses contain a running example and comprise about 60% of course time. The remaining 40% are in-depth exercises designed to reinforce key concepts.

Here’s a review of a class in Houston.

Model minded development

Sat, 25 Apr 2015 12:54:46 -0400

I gave a talk to the Princeton chapter of the ACM on Model Minded Development.

Many slides have no text, so you’ll want to go to the Full slide deck with speaker notes.

Abstract

Domain-Driven Design says that we should be mindful of domain models and embed them in our code.
Design Patterns say that we should know a catalog of patterns so we can solve recurring problems that arise in OO code.
Software Architecture says that unless we are mindful of large-scale patterns and models then our systems will not achieve the qualities we seek.
Test-Driven Design imposes a structure on our code so that it can be more easily tested.
Programming styles (functional, object-oriented, procedural, etc.) impose structure on our code.

The common denominator here is that software developers are expected to keep in mind many abstract yet complex models that constrain the code they write. In some ways these constraints are a burden and in other ways they are light that illuminates a path forward.

I discussed an idea called Model Minded Development that generalizes across DDD, Design Patterns, architecture, TDD, and coding styles. The defining characteristic of senior software developers is their facility with Model Minded Development and it enables them to operate at an advanced level.

What Agilists Should Know About Software Architecture

Mon, 17 Feb 2014 21:43:00 -0500

Michael Keeling and I had a video Hangout on Air today, chatting about the intersection of software architecture and agile.

Some of the topics discussed include: 3-tier architecture, YAGNI, quality attributes, big design up front, little design up front, design patterns, architecture patterns, walking skeletons, thin vertical slices, spiral model, system metaphor, extreme programming (XP), application frameworks, MVC, publish-subscribe, refactoring, architectural refactoring, refactoring vs rework, refactoring-to-patterns, lean thinking, last responsible moment, keeping options open as long as possible, Michael Waterman (NZ), cost-value-curve, “I’d love to have that problem”, architecture mismatch, conscious design decisions.

Video & Lecture on Intro to Software Architecture

Sat, 22 Sep 2012 00:00:00 -0400

This lecture, recorded at the University of Colorado Boulder in September 2012, is an introduction to the major concepts of software architecture. The audience consisted of 70 seniors majoring in computer science. It is based on material taken from the book Just Enough Software Architecture.

Most developers have no formal eduction in software architecture, yet a system’s architecture has a big influence on its success. Software architecture has been intensively researched for more than twenty years now and studying it will help you do a better job of designing systems, give you names for the concepts and patterns, and help you choose between competing designs.

References

Topics

Major topics covered in this lecture include:

Architects focus on system qualities
Tradeoffs
Architecture, architecting, architects
Views
Quality attributes
Analysis
Standard notations
Guiderails
Architectural styles
Conceptual model
Engineering with models
Canonical model structure
Models and code
Process and risk

The pacing of the lecture is considerably slower than when I give this lecture to industry practitioners because undergraduates need to be provided with more examples to ground the lessons. This lecture was just over 2 hours but with a different audience it would be about 75 minutes.

Exercise: Designing an alarm clock

Here is the exercise that goes along with the lecture. The point of the exercise is to focus attention not on the features of the alarm clock – all alarm clocks have reasonably equivalent features for our purposes – but instead on the qualities and the ways the clocks can fail.

Why would you choose a battery-based clock over one that plugs into the wall? Well, LED clocks are easy to read at night but generally start blinking 12:00 every time the power goes out. So there is a tradeoff between readability and reliability. But of course the battery can fail too…

The class structures its choices according to the “rational architecture choice” template, which looks like this:

Since X is a priority, we chose design Y, accepting downside Z.

I hope you enjoy it.

Updated Drupal site

Sat, 15 Sep 2012 00:00:00 -0400

Upgrading Drupal is always a bit stressful. It’s easy to get a site up and running and then customize it – but it’s exactly those customizations that can get lost in the upgrade. It appears to be all back to normal but let me know if you find anything that seems broken.

Conceptual Models of Software Architecture

Wed, 22 Aug 2012 00:00:00 -0400

Earlier this year, I gave talks at the GOTO Copenhagen and GOTO Amsterdam conferences. A few folks at the conferences called it “the dandelion talk” because there is an example in the middle of my conceptual model of how to get rid of dandelions in your yard. Of course the real idea is that conceptual models of architecture can help you become a better software engineer – the difference between the 20-year-old version of yourself and the older, master-builder version of yourself. This is perhaps my favorite of all the talks I’ve given, so I hope that you enjoy it too.

GOTO Copenhagen talk on conceptual models of software architecture

(Opens on InfoQ website; no easily embeddable video – but going to their site gives you both the video and the slides)

Architecture Hoisting - video of Atlanta talk

Sun, 18 Mar 2012 00:00:00 -0400

I presented my work on Architecture Hoisting last week in Atlanta. The big idea is that software often relies on global design constraints (guiderails) to achieve its qualities (e.g., reliability, security).

But you’ve really only got two options for ensuring those guiderails: (1) developer vigilance and (2) architecture hoisting. In the small (say inside of a data structure), using vigilance to keep an invariant is possible. In the large, architectural guiderails (self-imposed constraints that simplify the software) are much harder to ensure, as the recent remote exploit in Google Chrome (a use-after-free bug) illustrates.

The other option, architecture hoisting, has not been widely recognized so this talk gives it a clear definition, shows examples of it in use, and discusses its applicability and trade-offs.

Abstract

Software architecture focuses on quality attribute requirements, such as scalability or performance, that are overall properties of a system. This talk describes Architecture Hoisting, a a design technique where the architecture ensures an intensional design constraint (i.e., a guiderail) to achieve a global property. Discussed examples include the NASA JPL Mission Data System, Enterprise Java Beans, and the Apache Portable Runtime.

Speaking at Atlanta IASA, Weds 14th, 2012

Thu, 08 Mar 2012 00:00:00 -0500

I will be in Atlanta giving a talk on Architecture Hoisting next week at the local IASA chapter. The topic of architecture hoisting is in my book but I’ve had several requests to dig into it further and this talk is the result. Here’s the talk abstract:

Solve Problems by Hoisting Them into your Architecture

Architecture hoisting is an established technique that has only recently been identified and named. It is suitable when you have a challenging design problem that requires consistency in the implementation. Architecture hoisting assigns responsibility for a problem to the architecture itself with the intent of guaranteeing a goal or property of the system. Once a goal or property has been hoisted into the architecture, developers should not need to write any additional code to achieve it.

Book on sale: Now just $19.50 with free shipping (limited time)

Tue, 06 Mar 2012 00:00:00 -0500

A little while ago, several cases of my books were being shipped to Amazon by the US postal service but those cases went missing. The USPS claims to have never found them despite being well labeled and indeed having an Amazon packing list inside the box.

Fast forward to now and those books are showing up on Amazon and eBay. But all is not well! It seems they were sold by the USPS to scavengers who have put them up for sale. I’d thought that this would be no problem, but it appears that Amazon does not like it when others sell books below their wholesale price, so they’re penalizing my book and selling it at list price – but nobody pays retail prices for books.

So, rather than let the scoundrels profit, I’m letting readers profit. I’m selling the book myself as an Amazon Seller for $19.50 until the scavenged inventory makes its way through the system. So grab yourself an extra one and tell your friends since I’m not sure how long this will last.

–George