English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 4h 27m | 672 MB
Write object-oriented code that’s manageable, maintainable, and future-proof.
Keeping your object-oriented designs simple demands a creative approach—and that’s exactly what you’ll find in Simple Object-Oriented Design. This book is full of patterns and principles for reducing complexity, each one proven in author Mauricio Aniche’s 20-year career in software development. You’ll learn how to tackle code’s natural growth in complexity, and adopt a “good enough” approach that means it’s easy to refactor when requirements change.
You’ll discover insightful principles for:
- Making code readable and documented
- Improving consistency and encapsulation
- Managing dependencies
- Designing abstractions
- Handling infrastructure
- Effective modularization
Learn what constitutes both good and bad object-oriented software design, 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 will last the test of time, without slowing feature delivery to a crawl.
Even a simple object-oriented application can quickly become complex as it evolves. Each new class, method, or feature means more state and abstractions to manage, which in turn increases complexity, maintenance, and time spent detangling legacy code. It takes effort and skill to keep your codebase simple. This book shows you how.
Simple Object-Oriented Design: Create clean, maintainable applications presents practical design principles you can use to keep an object-oriented codebase simple as it grows and changes. Written as a collection of practical techniques you can apply in any OO language, it offers tips for concise code, managing dependencies and modules, and designing flexible abstractions. Illuminating figures, real-world examples, and insightful exercises make each principle stick.
What’s inside
- Writing simple, understandable classes
- Flexible abstractions to extend your designs
- Reducing the impact of coupling
Table of Contents
1 A short dive into the architecture of an information system
2 Designing simple object-oriented systems
3 Exercises
4 It s all about managing complexity
5 Simple design as a day-to-day activity
6 Summary
7 The example project PeopleGrow!
8 Exercises
9 Make code readable and documented
10 Making code small
11 Move new complexity away from existing classes
12 Summary
13 Design effective data validation mechanisms
14 Encapsulate state checks
15 Exercises
16 Keeping objects consistent
17 Model aggregates to ensure invariants in clusters of objects
18 Provide only getters and setters that matter
19 Summary
20 Avoid coupling to details or things you don t need
21 Break down classes that depend on too many other classes
22 Exercises
23 Inject dependencies, aka dependency injection
24 Managing dependencies
25 Summary
26 Designing good abstractions
27 Exercises
28 Generalize important business rules
29 Prefer simple abstractions
30 Summary
31 Encapsulate low-level infrastructure errors into high-level domain errors
32 Exercises
33 Handling external dependencies and infrastructure
34 Only depend on things you own
35 Summary
36 Use the infrastructure fully
37 Achieving modularization
38 Design clear interfaces
39 Exercises
40 No intimacy between modules
41 Summary
42 Accept that your code won t ever be perfect
43 Being pragmatic
44 Consider redesigns
45 Exercises
46 Refactor aggressively but in small steps
47 References
48 Summary
49 You owe this to junior developers
Resolve the captcha to access the links!