Book description
Objects are the central concept of languages like Java, Python, C#. Applying best practices for object design means that your code will be easy to read, write, and maintain. Object Design Style Guide captures dozens of techniques for creating pro-quality OO code that can stand the test of time. Examples are in an instantly familiar pseudocode, teaching techniques you can apply to any OO language, from C++ to PHP.About the Technology
Well-written OO code is a pleasure to read, modify, and debug. Elevate your coding style by mastering the universal best practices for object design presented in this book. These clearly presented rules, which apply to any OO language, maximize the clarity and durability of your codebase and increase productivity for you and your team.
About the Book
Object Design Style Guide presents dozens of professional techniques for writing OO code. In it, veteran developer Matthias Noback lays out design rules for constructing objects, defining methods, changing and exposing state, and much more. All examples use instantly familiar pseudocode, so you can follow along in the language you prefer. You’ll go case by case as you explore important scenarios and challenges for object design and then walk through a simple web application that demonstrates how different types of objects can work together effectively.
What's Inside
- Universal design rules for a wide range of objects
- Best practices for testing objects
- A catalog of common object types
- Exercises for each chapter to test your object design skills
About the Reader
For readers familiar with an object-oriented language and basic application architecture.
About the Author
Matthias Noback is a professional web developer with nearly two decades of experience. He runs his own web development, training, and consultancy company called “Noback’s Office.”
Quotes
Offers both guidelines and guidance on how to achieve a clear, consistent tone across a larger team.
- From the Foreword by Ross Tuck
Demystifies OOP and describes how to use it to design truly secure and performant applications.
- Charles Soetan, Plum.io
Extremely well-written content for all skill levels in the industry.
- Shayn Cornwell, XeroOne Systems
An objective go-to reference for programmers wanting to standardize their OOP procedures.
- Joseph T. Lyons, SYSCON International
Publisher resources
Table of contents
- Copyright
- Brief Table of Contents
- Table of Contents
- Foreword
- Preface
- Acknowledgments
- About this Book
- About the Author
- About the Cover Illustration
- Chapter 1. Programming with objects: A primer
-
Chapter 2. Creating services
- 2.1. Two types of objects
- 2.2. Inject dependencies and configuration values as constructor arguments
- 2.3. Inject what you need, not where you can get it from
- 2.4. All constructor arguments should be required
- 2.5. Only use constructor injection
- 2.6. There’s no such thing as an optional dependency
- 2.7. Make all dependencies explicit
- 2.8. Task-relevant data should be passed as method arguments instead o- of constructor arguments
- 2.9. Don’t allow the behavior of a service to change after it has been instantiated
- 2.10. Do nothing inside a constructor, only assign properties
- 2.11. Throw an exception when an argument is invalid
- 2.12. Define services as an immutable object graph with only a few entry points
- Summary
- Answers to the exercises
-
Chapter 3. Creating other objects
- 3.1. Require the minimum amount of data needed 3.1 to behave consistently
- 3.2. Require data that is meaningful
- 3.3. Don’t use custom exception classes for invalid argument exceptions
- 3.4. Test for specific invalid argument exceptions by analyzing the ex- xception’s message
- 3.5. Extract new objects to prevent domain invariants from being verif- fied in multiple places
- 3.6. Extract new objects to represent composite values
- 3.7. Use assertions to validate constructor arguments
- 3.8. Don’t inject dependencies; optionally pass them as method arguments
- 3.9. Use named constructors
- 3.10. Don’t use property fillers
- 3.11. Don’t put anything more into an object than it needs
- 3.12. Don’t test constructors
- 3.13. The exception to the rule: Data transfer objects
- Summary
- Answers to the exercises
-
Chapter 4. Manipulating objects
- 4.1. Entities: Identifiable objects that track changes and record events
- 4.2. Value objects: Replaceable, anonymous, and immutable values
- 4.3. Data transfer objects: Simple objects with fewer design rules
- 4.4. Prefer immutable objects
- 4.5. A modifier on an immutable object should return a modified copy
- 4.6. On a mutable object, modifier methods should be command methods
- 4.7. On an immutable object, modifier methods should have declarative names
- 4.8. Compare whole objects
- 4.9. When comparing immutable objects, assert equality, not sameness
- 4.10. Calling a modifier method should always result in a valid object
- 4.11. A modifier method should verify that the requested state change is valid
- 4.12. Use internally recorded events to verify changes on mutable objects
- 4.13. Don’t implement fluent interfaces on mutable objects
- Summary
- Answers to the exercises
- Chapter 5. Using objects
-
Chapter 6. Retrieving information
- 6.1. Use query methods for information retrieval
- 6.2. Query methods should have single-type return values
- 6.3. Avoid query methods that expose internal state
- 6.4. Define specific methods and return types for the queries you want to make
- 6.5. Define an abstraction for queries that cross system boundaries
- 6.6. Use stubs for test doubles with query methods
- 6.7. Query methods should use other query methods, not command methods
- Summary
- Answers to the exercises
-
Chapter 7. Performing tasks
- 7.1. Use command methods with a name in the imperative form
- 7.2. Limit the scope of a command method, and use events to perform secondary tasks
- 7.3. Make services immutable from the outside as well as on the inside
- 7.4. When something goes wrong, throw an exception
- 7.5. Use queries to collect information and commands to take the next steps
- 7.6. Define abstractions for commands that cross system boundaries
- 7.7. Only verify calls to command methods with a mock
- Summary
- Answers to the exercises
- Chapter 8. Dividing responsibilities
-
Chapter 9. Changing the behavior of services
- 9.1. Introduce constructor arguments to make behavior configurable
- 9.2. Introduce constructor arguments to make behavior replaceable
- 9.3. Compose abstractions to achieve more complicated behavior
- 9.4. Decorate existing behavior
- 9.5. Use notification objects or event listeners for additional behavior
- 9.6. Don’t use inheritance to change an object’s behavior
- 9.7. Mark classes as final by default
- 9.8. Mark methods and properties private by default
- Summary
- Answers to the exercises
- Chapter 10. A field guide to objects
- Chapter 11. Epilogue
- Appendix: Coding standard for the code samples
- Style guide cheat sheet
- Index
- List of Figures
- List of Tables
- List of Listings
Product information
- Title: Object Design Style Guide
- Author(s):
- Release date: January 2020
- Publisher(s): Manning Publications
- ISBN: 9781617296857
You might also like
audiobook
Object Design Style Guide
Offers both guidelines and guidance on how to achieve a clear, consistent tone across a larger …
book
Design It!
Don't engineer by coincidence-design it like you mean it! Filled with practical techniques, Design It! is …
video
Object Design Style Guide video edition
Offers both guidelines and guidance on how to achieve a clear, consistent tone across a larger …
audiobook
The Design of Everyday Things
First, businesses discovered quality as a key competitive edge; next came science. Now, Donald A. Norman, …