Architecture Patterns with Python: Enabling Test-Driven Development, Domain-Driven Design, and Event-Driven Microservices 1st Edition, Kindle Edition

Authors: Harry J.W. Percival, Bob GregoryPublisher: O'ReillyPublication Date: 3/5/2020Disclaimer: I am reviewing my own copy of this book because I want to. The publisher did not provide me with a copy. I promise to be 100% honest in how I feel about this book, both the good and the less so.About the BookThis is an introductory software engineering book that gives you more hand-on experience than your typical software engineering course. The authors discuss domain-driven design, test-driven development, the basic concepts of object-oriented programming, and general software architecture. It's broken up into two parts: Building an Architecture to Support Domain Modeling and Event-Driven Architecture, with a bit extra thrown in at the end to fill in some gaps. This is an unofficial follow up to one author's previous book, Test-Driven Design in Python.The first half, on building the architecture, gives you a high level view of your software and about setting it up for success. It starts with an introduction to domain modelling, discusses basic architecture patterns, and gives examples of the Flask API. It finishes with setting up your tests and being ready to add the meat to the bones. The second half, on event-driven architecture, looks at event handling and the message bus that serves of the backbone of your application.Who is This For and Why Was it Written?In the preface, the authors claim that you are an experienced Python developer who has developed applications with at least a moderate amount of complexity, You have realized how difficult this can be, but you don't know much if anything about Domain Driven Design or basic architecture patterns.I would expand this to a slightly wider audience. If you're an advanced undergraduate who has spent their university career working in Python and were not satisfied with your Software Engineering course, this book is for you. If you are about to create your own open source project with even the slightest bit of complexity, this book is for you. If you want to work on or take over an abandoned open source project, this book is for you. There are other people this is for, but I'll end the list here.I would argue that this book fills a gap left by a LOT of software engineering books. First, it gives you a hands-on experience, so long as you follow the code. Second, is discusses patterns that I never learned in my software engineering course. Third, it gives a good introduction to microservices, which are common right now.OrganizationThe first part of the book begins as soon as the introduction ends. Half way through the book, they leave the architecture and look at the code running within that architecture. Then it finishes with a series of appendices that fill in missing bits, expand on important topics, or give alternatives to how the main parts of the book handled this topic. One example is how to use Django rather than Flask to achieve the same results.Within a chapter, there are a page or two that gives you a high level view of the upcoming text. Each chapter comes in at 15-25 pages of clear written prose. Then they finish up with a Wrap-Up (Summary) section where they review what you just read while also giving you a taste of what is to come.Did This Book Succeed?I think that this book does very well. As someone who wants to write their own large program without knowing where to start (like so many of us), I picked up this book at just the right time. It's not going to teach you all of software engineering (which they did not claim to do), nor is it going to teach you Python. This is an intermediate level book who want to expand their developer's toolbox. t was well organized, well written, and very much needed, as one of the few books of its kind.Rating and Final ThoughtsThis is a great book, which earns a 5 out of 5. It's the book I need the most right now, as it will let me step up with my Python development. I very much hope that the authors consider collaborating again for a design pattern book for Python. I would expect it to be as well organized and written.

As a self-learner, I have read a lot of python books and have learned a ton from them. This book may not only greatly improve the way I write python, but I think it will transform the department I work for and other teams that use python.This book covers topics that aren't touched by most python books, and is an excellent resource to help you develop any python program, especially one that needs to get or save data from a database, interact with HTTP requests, or abstract business procedures.The reason I gave this book so many stars is not only for the topics that needed covering, but also the way they talk about them. The authors discuss the trade offs of the approaches they bring up, which is not done enough in the programming world.The book is easy to read, they have great exercises you can do on your own to pick up the concepts, and you will become a better programmer after absorbing the ideas in this book.

Many python developers may start with a simple idea in mind: python is easy to learn and use. They are right. Compare to many older programming languages, python allows you a quick start to build something useful. However, that also means that a lot of python developers can be less trained on those important programming principles. I have seen many people using python as quick and dirty ways to develop product in a professional environment because they don't know better. I have done similar things too. This book provides a concrete example to guide you on the path to develop a well designed product. In contrast to some programming book, in which high level concept is introduced, this book does it from bottom up. It starts with common design mistakes and correct them through the chapters.This is not a book for python starters. If you haven't had the need to design a product or a python module, or you haven't had the basic understanding of python, you may find this book difficult. In that case, you might want to start with Fluent Python.That been said, if you are a python developer and are asking yourself "what do I do to design a good product", I would strongely recommend this book.

Designing software has never been a deterministic field. Meaning, when creating an app, there's no one way to do things. Change is always inevitable. That's where the book comes in. It gives a sense of "determinism" to designing large-scale apps. But this book contains one flaw - not related to the content itself - but to the presentation/printing. I just wish that O'Reilly took care in printing the diagrams more. At least, the diagrams should be colored the same as the ebook versions.

I enjoyed this one enough I'll probably read it twice. Fun and well written, basically never a slog. There's not a lot written on practical large scale application design in python and this was a real treat. I see a ton of ideas I'll apply immediately and others I've already been doing intuitively. Highly recommended.

I've been a professional developer in various languages over the last two decades and there has always been a gap in programming books at the point where you've learnt all the syntax and APIs but then need to know how to actually put a big system together properly. There are books about design patterns and about XP and Agile but I have always been missing that book or two that says "This is how to put together a real system with real code in the real world."This book is one of the few out there that fulfil that purpose and the only one I know of using Python. You can use it by your side as you're working and contemplating architecture decisions - this isn't a hand-wavy book that you read on holiday.The authors work for an international furniture company and use examples from their work which are real but also comprehensible - you can understand that they want to improve delivery times and follow their thinking as they do it.I recommend this book to anyone who has some experience with Python and wants to build robust and maintainable systems and wants to spend less time wondering how to organise their thinking.Personally, I'm making the switch to Python from decades of PHP and this has been a great help in learning more architecture (that is usable in any language) and learning how to do things well in Python.

I've had an interest in Domain Driven Design ever since picking up the Evans book over a decade ago. A fascinating read, but could've been half the size. Since then, there have been other DDD books, all fine texts in their own way, but let down by also being larger than they should be and making the assumption you're using a verbose, statically typed language like Java or C# (presumably to appear "enterprisey").There's been a definite need for something covering DDD from the perspective of dynamic languages. From my own experience of 23 years as a professional developer, dynamic languages are just as good at writing large software, and arguably the better choice for writing code that is clearer, cleaner, and closer to the domain. Well, this book successfully fills the gap: distilling the key points of DDD in a concise, pragmatic way that's accessible to Python developers.I'm hard-pressed to think of other Python books that tackle large-scale software development and architectural design, so even if you're not too fussed about DDD, it's still a worthy read to broaden your "enterprise" Python skills.Given the lack of DDD coverage for dynamic languages, this might also be of use to non-Pythonistas, although you'll need some familiarity with the language. Trust me, it's not too difficult to pick it up if you come from languages like Ruby or JavaScript.If I have just one grumble, and I haven't docked points for this because it's not the fault of the authors, but O'Reilly books are very expensive these days at full price (I've been buying O'Reilly books for almost 30 years). Fortunately, I managed to grab a copy here at a much more reasonable price - I hope I haven't cost the authors some royalties!

The writing style is approachable and clear and very consice - there is no waffle.The book introduces a moderate number of patterns without disappearing into academia. Everything is throughly grounded in the real world, and you are brought through the material in a way that is hightly relatable.For our own codebase, this book has the highest density of applicability to the problems that my team faces - by a long long way! Much as I like Clean Code and The Pragmatic Programmer, those books leave it to the reader to relate the learning back to their own daily problems. This book makes it so easy to see a path forward in your daily work.You can read this and come out with immediate and concrete actions for your codebase, and arguments you can make in favour of those actions.It is fairly high in code snippets, although they are all short and very comprehensible.This book is an absolute must if you are in a young team that is trying to build its engineering practices. You can give this book to someone who has no concept of patterns and they will get it just as easily as if they had read GoF.Definitely one of my top three books, and I am arguing for my team to use this book in place of writing our own coding guidelines.I think that the book goes a little further than I'd like in the jokey over-approachable "hey look we're nerds here" style, but it isn't enough to annoy. That's literally the only thing I can think to change. It's essentially perfect.Bob, Harry, thank you, you have helped us.

This is not a beginners Python book, but a practical guide to Domain-Driven Design (DDD).I have long experience with Python and SQLAlchemy, and this book is on the right level for me.In the last few years, I have got a growing realization that I have used mocks wrong, just to get high code coverage in my tests, without any assurance to restructure my code. I have seen inspiring talks about dependency injection but never used it. Thought it to have a too high cost and risk to change a legacy system.This book goes through many patterns, explained with practical examples and some exercises. I have read other architecture patterns books that have been too academic for me and with code in Java.I highly recommend this book.

The material in this book is very accessible with tests and code samples throughout and all code available online to download and run as you work through it.The authors present a set of patterns that they have successfully used to control complexity in a real system and clearly explain their choices and alternatives. They start simple and guide the reader through identifying a problem, discussing alternative solutions and explaining the reasoning behind their recommended pattern.It's a thoroughly worthwhile read for team that needs to control complexity.