4 weeks, 24 hours in total
Two evening classes a week
Up to 10 people in a group
The early 20th century saw a lot of anxiety about art's loss of social relevance and the soullessness of mass manufacturing. Bauhaus aimed to reunite fine art and functional design, creating practical objects with souls of artwork. This course aims to do the same for software: unite the theoretical computer science with practical software engineering, resulting in beautiful code and good, maintainable and extendable architecture.
This is easier said than done: how do you teach design? We try it all: from general abstractions for problem solving and managing complexity, through classical design patterns and best practices, to more novel ideas about building platforms, decoupling and disaggregation.
We'll talk about the usual suspects: dependencies, state, edge cases and compounding complexities. There are many ways to mitigate it — whether it's practical methods like dependency injection and Uncle Bob's Clean Architecture, or philosophical ideas like the Pareto principle, the Sapir-Whorf hypothesis, progressive disclosure, "worse is better" and many more.
Then, we'll try the old way, and go over design patterns such as strategy, abstract factory, singleton, factory method and template method. We'll see why they used to work, and why they're mostly irrelevant at this point, settling once and for all the immortal question of composition vs. inheritance.
Instead, we'll take a novel approach, and draw inspiration from industrial design, architecture and urbanism. We'll see how people tend to focus on short-lived solutions, rather than build platforms that enable the future (and how to do so from a project management perspective). We'll review real case studies from Unix and Python, as well as practical examples like plugins, middleware and aspect-oriented programming.
Finally, we'll talk about the bigger picture, and see how all the components fit within one architecture. Whether it's utilities like proper logging and configurations, or infrastructures like databases (both SQL and NoSQL) or message queues, we'll learn to disaggregate them intro microservices, spin everything using Docker and Kubernetes, and deploy it to the cloud, wrapping everything up in nice, RESTful and gRPC APIs.
The course is intended for experienced programmers who want to broaden their horizons and learn new ways to tackle the challenges of software engineering and design. You should be familiar with Python (ideally, having done my other course), and understand that there's no silver bullet: we won't learn one method to rule them all, but rather have a dialectical overview of different paradigms, and understand the philosophy behind each one.
Knowledge should be free — that's why I publish a lot of my materials online. But seeing as I can't scale my time, I have to charge money for it; and unfortunately, some people don't have the means to participate. So, every course iteration, one spot will be reserved for someone who couldn't have afforded it otherwise.
If you think you qualify, shoot me an email, tell me a bit about yourself, why you're interested in the course, and your situation — and we'll figure something out.