In the agile world,
where individual programmers make design decisions on a minute-by-minute basis,
excellent code structure—and the design knowledge that makes that
structure possible—is essential.  Without it, your code will not be
able to stand up to the stress of changing requirements. 

This class covers the structural side of object-oriented design in
considerable depth.  Topics include class-hierarchy structure (and fragile
base classes), accessors and mutators, the SOLID principles,
and most importantly, a contemporary and in-depth look at the Gang-of-Four design
patterns. 

This class is a very practical deep dive into the mechanics of a
front-end architecture suited for situations where requirements and code are constantly changing. 

The class is a great way to quickly come up to speed on all the
technologies that you need to build an effective web-based front end,
including Typescript, Bootstrap, ReactJS, and Angular2, which
we examine in depth. 
We also a look at the large-picture front-to-back architecture for volatile environments. 

This is a hands-on class, and over the course of the class,
we'll build a single-page-web-application front end that leverages these
technologies and others. 

This class is a very practical deep dive into the mechanics of micro-services:
a back-end architecture particularly suited for development
environments where requirements and code are in constant flux. 
The class takes a case-study approach,
looking at several micro-services (that implement a small blogging system). 

Through a series of hands-on exercises, we'll build several services,
using the server-side language of your choice. 
We'll look at deployment on both your own server and
to the Amazon cloud (AWS).  We'll also look at two NoSQL database
systems: MongoDB and Amazon Dynamo. 

You'll come away from this class with a deep understanding of how
to build production-quality micro-services and deploy them either
on your own sever or in the cloud using AWS. 

We are, ourselves, an agile organization.  Consequently, we're
happy to customize a class to your needs from the material presented
in our main curriculum.  Our most-popular mixes are:

The Agile/OO Design Workshop (3-days minimum):

This class combines the Agility and Designing for Volatility
classes.  It's an effective introduction to the "Agile"
way of working, with a focus on agile culture and non-tribal
practice, not a specific practice framework.  The minimal (3-day)
version includes a hands-on exercise in which we start with an idea
and take it through to a design from which you could code. 
Add additional days to make the exercise more detailed (and realistic). 
The exercise is typically a problem brought to class by one
of the students, and we're happy to work on something relevant
to your current projects. 

Agile Architecture, an Overview (1-day):

An fast-paced lecture-only overview of the entire
agile-technology stack discussed in Designing for Volatility I and II. 

Agile Architecture and Implementation (3-day):

This class is a lecture-only amalgam of Designing for
Volatility and the two Agile Architecture classes. 

This hands-on class is an in-depth look at Google's Angular2 framework. 
It uses a case-study approach, analyzing a small blogging application. 
Coming to the class with nothing but a little JavaScript and basic HTML, you'll
come away knowing enough Angular2 to use it effectively to build nontrivial
real-world applications. 
You'll thoroughly understand Angular2's architecture and how Angular fits into
your larger application, and along the way, you'll learn a little
TypeScript (everything you need to write an Angular2 application). 

Apple's Swift programming language is one of the best languages for general programming.  It's essential in the Apple environment, of course, but Swift is also a great choice for the Server. ( There's a robust open-source project.)  Swift combines all the best features of both OO and functional languages, without the obscure syntax that you find in similar efforts (like Scala).  It's compact syntax and focus on readability make it a better alternative to Java. 

This course introduces Swift 3.x in considerable technical depth, focusing on those parts of the language that you will find new or unfamiliar.  This course is geared to working programmers—prior experience with an OO language is required.  You don't need to know anything about the Apple ecosystem, however: this is a language course, not an iOS or OSX programming course. 

DbC (Design by Coding) is a architectural-level design technique that lets
you build a coherent domain-centric architecture incrementally as
a system evolves. 
It extends the techniques of TDD and BDD to the architectural level,
starting with user stories and ending up with an optimal implementation
of that story. 
You create the code and develop the architecture simultaneously. 
The result is a coherent minimal system ideal for Agile development
environments or any development process that doesn't rely on large
up-front design. 

There's a short (10 minute) introduction on the
video page,
but there's a lot to DbC than you can't get in a 10-minute video. 

This one-day hands-on class takes you through the entire design process,
covering both theory and practices.  We'll develop a working system in
class, using your preferred language and development environment.