Welcome to our series on Architecture. In this series we are going to cover many topics. We’ll start at the beginning with a review of the paradigms and principles of low level software design. We’ll commence from there to a review of components and the principles that define them. And from that vantage point we will graduate to Architecture itself and explore the art of drawing lines and techniques for enforcing boundaries. But that’s not what we are doing in this first episode. In this episode we’re going to answer the question that motivates this next set of episodes. “What is Architecture?”

At the very lowest level of software architecture is code, and the rules of clean code. At the next level are the paradigms of programming, and that's what we'll be focussing on in this episode. The three paradigms, Structured Programming, Object Oriented Programming, and Functional Programming were all discovered in the decade between 1957 and 1968. In this episode we'll discuss the history of those paradigms, and then we'll dig down into the architectural significance of each in turn. Finally, we'll synthesize them into an architectural whole with the following conclusion: Well architected software systems are composed of recursive applications of sequence, selection, and iteration, hung on a framework of inverted dependencies and plumbed through and through with flows of immutable data.

You all know the SOLID principles by now. (If you don't, check out our series on the topic) How do those principles relate to architecture? That's the question that this episode tackles. We walk through a quick review of the SOLID and Component principles, and then discuss how each applies at the higher level of architecture. At the end we bring it together into a grand synthesis.

So now our jaunt through the topic of software architecture is starting to heat up. This is the episode where we get nitty-gritty, down and dirty. We talk about drawing lines. We’ll begin by discussing what architecture is -- really. Then we’ll tackle the concept of independence, and what it means to be independently deployable, and independently developable. Next we’ll discuss the anatomy and physiology of architectural boundaries, and we’ll hear some sad stories of boundaries that were mis-drawn. We’ll conclude, at the climax, with a discussion of policy and level, which will lay the stage for Episode 67 -- Clean Architecture. So, ready or not, here we come with Episode 66: The Art of Drawing Lines.

In this, the final episode on Architecture, we begin by discussing the structure of business rules and business data. Then we talk about how architectures should scream those business rules to programmers. Next we walk though a prototype four layer architecture that I like to call The Clean Architecture. Lastly we spend some time talking about all the low level things that don't neatly fit into any architecture. Things like main, configuration, tests, and low level drivers and utilities. And finally, we talk about how to get off the planet. Have fun, everybody!