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