Agility
Architecture under Stress
The Single-Page Web App (Agile Architecture I)
Micro-service Back Ends (Agile Architecture II)
DbC: Design by Coding
Roll Your Own Agile-Culture or Agile-Architecture Class
Angular 2 (And A Little Typescript): A Case-Study Approach Swift in Depth
Public Classes

Agility

1 or 2 day lecture only, 3-5 days hands on.

Agility is something that you are, not something that you do in the engineering department. To be agile is to be flexible, adaptable, nimble. You can adapt quickly to change and build products that delight your customers with lightning speed. Anything that slows you down is your enemy. Scrum is part of that picture, but there's way more to being agile than doing Scrum.

This class teaches you big-picture agile. You'll learn all the big-three processes (XP, Scrum, Kanban), but that's actually a small part of the class. You'll learn how those processes actually work, and why we do the things we do. You'll learn how to build an effective agile culture, without which the processes will fail.

This class is an essential first step if you're considering agile, and an essential next step if you want to evolve beyond the baby steps that Scrum represents. The class covers what it really means to be agile and how to get there.

Architecture under Stress

3-to-5 day workshop

You can implement an Agile process perfectly, but if your underlying system architecture can't stand up to the stress of constant change, you will fail. This class shows you how to design/build for volatility. It is essential background for everybody who's working in a volatile environment, were requirements change as you're working. Moreover, the architecture has to evolve incrementally along with the system. The days of monolithic up-front design are over.

This hands-on workshop covers the entire design process, starting with "user stories" and ending with a full implementation architecture. We'll look at how to factor stories, how to extract architectural elements from them, and how to derive classes and micro-services from them. We'll look at the system from both the internal-structure and the system-architecture perspective. We will go through the entire process with a hands-on exercise, during which we develop a design and architecture that solves a real-world problem.

Design Patterns and Program Structure

1-or-2 day lecture

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.

The Single-Page Web App (Agile Architecture I)

3-day workshop

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.

Micro-service Back Ends (Agile Architecture II)

3-day workshop

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.

Roll Your Own Agile Class:

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.

Angular 2 (And A Little Typescript):
A Case-Study Approach

1-day hands-on

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).

Swift in Depth

2-day hands-on

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

1-day hands-on

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.