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 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 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.
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:
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.
An fast-paced lecture-only overview of the entire agile-technology stack discussed in Designing for Volatility I and II.
This class is a lecture-only amalgam of Designing for Volatility and the two Agile Architecture classes.
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
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.