Catecismo Romano

Write object-oriented code that's manageable, maintainable, and future-proof. Inside Simple Object-Oriented Design you'll discover insightful principles for reducing complexity in your object-oriented code, including: Designing classes that are always in consistent states Creating abstractions that make it easy to extend software in highly flexible ways Lessening the impact of coupling on your codebase Modeling class designs that abstract away infrastructure details and use your infrastructure to its maximum capacity Reducing the complexity of your code Simple Object-Oriented Design: Create clean, maintainable applications is a comprehensive handbook of design practices, principles, and patterns that help simplify object-oriented software. The book is aimed at the working developer. There's no perfection-chasing classroom theory that fails in practice--you'll master "good enough" techniques that are effective in real-world environments. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the technology As your software grows and expands, every new feature and functionality potentially adds complexity to your codebase. The result? Bugs, crashes, and too much time spent detangling incomprehensible legacy code. Properly applied design principles help you ensure your applications are easy to manage for the long term. About the book Simple Object-Oriented Design is full of techniques to keep your object-oriented code simple even as your applications evolve and grow. Each principle in this book has been tested and proven in author Mauricio Aniche's 20-year career in software development. You'll learn what constitutes both good and bad object-oriented software design, and how to manage dependency, modules, and other features that give rise to complexity. Discover how to make better trade-offs in design decisions, and when to embrace complexity over simpler data structures. With this book as your vital reference, you'll be ready to write code that's flexible for the future without slowing feature delivery to a crawl. About the reader For readers who know an object-oriented language. This book's Java examples are easy to understand for any developer. About the author Dr. Maurício Aniche's life's mission is to make software engineers better at what they do. He is a tech lead at Adyen and an Assistant Professor in Software Engineering at Delft University of Technology. Maurício is the author of Effective Software Testing: A Developer's Guide published in 2022, by Manning, a book that's already adopted by universities throughout the world. Simple Object-Oriented Design Copyright dedication contents front matter preface acknowledgments about this book Who should read this book How this book is organized: A road map About the code liveBook discussion forum Other online resources about the author about the cover illustration 1 It’s all about managing complexity 1.1 Object-oriented design and the test of time 1.2 Designing simple object-oriented systems 1.2.1 Simple code 1.2.2 Consistent objects 1.2.3 Proper dependency management 1.2.4 Good abstractions 1.2.5 Properly handled external dependencies and infrastructure 1.2.6 Well modularized 1.3 Simple design as a day-to-day activity 1.3.1 Reducing complexity is similar to personal hygiene 1.3.2 Complexity may be necessary but should not be permanent 1.3.3 Consistently addressing complexity is cost effective 1.3.4 High-quality code promotes good practices 1.3.5 Controlling complexity isn’t as difficult as it seems 1.3.6 Keeping the design simple is a developer’s responsibility 1.3.7 Good-enough designs 1.4 A short dive into the architecture of an information system 1.5 The example project: PeopleGrow! 1.6 Exercises Summary 2 Making code small 2.1 Make units of code small 2.1.1 Break complex methods into private methods 2.1.2 Move a complex unit of code to another class 2.1.3 When not to divide code into small units 2.1.4 Get a helicopter view of the refactoring before you do it 2.1.5 Example: Importing employees 2.2 Make code readable and documented 2.2.1 Keep looking for good names 2.2.2 Document decisions 2.2.3 Add code comments 2.2.4 Example: Deciding when to send an update email 2.3 Move new complexity away from existing classes 2.3.1 Give the complex business logic a class of its own 2.3.2 Break down large business flows 2.3.3 Example: Waiting list for offerings 2.4 Exercises Summary 3 Keeping objects consistent 3.1 Ensure consistency at all times 3.1.1 Make the class responsible for its consistency 3.1.2 Encapsulate entire actions and complex consistency checks 3.1.3 Example: The Employee entity 3.2 Design effective data validation mechanisms 3.2.1 Make preconditions explicit 3.2.2 Create validation components 3.2.3 Use nulls carefully or avoid them if you can 3.2.4 Example: Adding an employee to a training offering 3.3 Encapsulate state checks 3.3.1 Tell, don’t ask 3.3.2 Example: Available spots in an offering 3.4 Provide only getters and setters that matter 3.4.1 Getters that don’t change state and don’t reveal too much to clients 3.4.2 Setters only to attributes that describe the object 3.4.3 Example: Getters and setters in the Offering class 3.5 Model aggregates to ensure invariants in clusters of objects 3.5.1 Don’t break the rules of an aggregate root 3.5.2 Example: The Offering aggregate 3.6 Exercises Summary 4 Managing dependencies 4.1 Separate high-level and low-level code 4.1.1 Design stable code 4.1.2 Interface discovery 4.1.3 When not to separate the higher level from the lower level 4.1.4 Example: The messaging job 4.2 Avoid coupling to details or things you don’t need 4.2.1 Only require or return classes that you own 4.2.2 Example: Replacing the HTTP bot with the chat SDK 4.2.3 Don’t give clients more than they need 4.2.4 Example: The offering list 4.3 Break down classes that depend on too many other classes 4.3.1 Example: Breaking down the MessageSender service 4.4 Inject dependencies, aka dependency injection 4.4.1 Avoid static methods for operations that change the state 4.4.2 Always inject collaborators: Everything else is optional 4.4.3 Strategies to instantiate the class together with its dependencies 4.4.4 Example: Dependency injection in MessageSender and collaborators 4.5 Exercises Summary 5 Designing good abstractions 5.1 Design abstractions and extension points 5.1.1 Identifying the need for an abstraction 5.1.2 Designing an extension point 5.1.3 Attributes of good abstractions 5.1.4 Learn from your abstractions 5.1.5 Learn about abstractions 5.1.6 Abstractions and coupling 5.1.7 Example: Giving badges to employees 5.2 Generalize important business rules 5.2.1 Separate the concrete data from the generalized business rule 5.2.2 Example: Generalizing the badge rules 5.3 Prefer simple abstractions 5.3.1 Rules of thumb 5.3.2 Simple is always better 5.3.3 Enough is enough 5.3.4 Don’t be afraid of modeling abstractions from day one 5.3.5 Example: Revisiting the badge example 5.4 Exercises Summary 6 Handling external dependencies and infrastructure 6.1 Separate infrastructure from the domain code 6.1.1 Do you need an interface? 6.1.2 Hide details from the code, not from the developers 6.1.3 Changing the infrastructure someday: Myth or reality? 6.1.4 Example: Database access and the message bot 6.2 Use the infrastructure fully 6.2.1 Do your best not to break your design 6.2.2 Example: Cancelling an enrollment 6.3 Only depend on things you own 6.3.1 Don’t fight your frameworks 6.3.2 Be aware of indirect leakage 6.3.3 Example: Message bot 6.4 Encapsulate low-level infrastructure errors into high-level domain errors 6.4.1 Example: Handling exceptions in SDKBot 6.5 Exercises Summary 7 Achieving modularization 7.1 Build deep modules 7.1.1 Find ways to reduce the effects of changes 7.1.2 Keep refining your domain boundaries 7.1.3 Keep related things close 7.1.4 Fight accidental coupling, or document it when you can’t 7.2 Design clear interfaces 7.2.1 Keep the module’s interface simple 7.2.2 Backward-compatible modules 7.2.3 Provide clean extension points 7.2.4 Code as if your module will be used by someone with different needs 7.2.5 Modules should have clear ownership and engagement rules 7.3 No intimacy between modules 7.3.1 Make modules and clients responsible for the lack of intimacy 7.3.2 Don’t depend on internal classes 7.3.3 Monitor the web of dependencies 7.3.4 Monoliths or microservices? 7.3.5 Consider events as a way to decouple modules 7.3.6 Example: The notification system 7.4 Exercises Summary 8 Being pragmatic 8.1 Be pragmatic and go only as far as you must 8.2 Refactor aggressively but in small steps 8.3 Accept that your code won’t ever be perfect 8.4 Consider redesigns 8.5 You owe this to junior developers 8.6 References 8.7 Exercises Summary index Write object-oriented code thats manageable, maintainable, and future-proof. Inside Simple Object Oriented Design youll discover insightful principles for reducing complexity in your object-oriented code, Simple Object Oriented A guide to creating clean, maintainable code is a comprehensive handbook of design practices, principles, and patterns that help simplify object-oriented software. The book is aimed at the working developer. Theres no perfection-chasing classroom theory that fails in practiceyoull master good enough techniques that are effective in real-world environments. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the technology As your software grows and expands, every new feature and functionality potentially adds complexity to your codebase. The result? Bugs, crashes, and too much time spent detangling incomprehensible legacy code. Properly applied design principles help you ensure your applications are easy to manage for the long term. About the book Simple Object Oriented Design is full of techniques to keep your object-oriented code simple even as your applications evolve and grow. Each principle in this book has been tested and proven in author Mauricio Aniches 20-year career in software development. Youll learn what constitutes both good and bad object-oriented software design, and how to manage dependency, modules, and other features that give rise to complexity. Discover how to make better trade-offs in design decisions, and when to embrace complexity over simpler data structures. With this book as your vital reference, youll be ready to write code thats flexible for the future without slowing feature delivery to a crawl. About the reader For readers who know an object-oriented language. This books Java examples are easy to understand for any developer. About the author Dr. Maurcio Aniche 's life's mission is to make software engineers better at what they do. He is a tech lead at Adyen and an Assistant Professor in Software Engineering at Delft University of Technology. Maurcio is the author of Effective Software A Developer's Guide published in 2022, by Manning, a book thats already adopted by universities throughout the world.