Simple Object Oriented Design: A guide to creating clean, maintainable code

By Herbert Schildt

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.

Purchase of the print book includes a free eBook in PDF and ePub formats from Manning Publications.

About the technology

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.

About the book

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

About the reader

Readers should be familiar with an object-oriented language like Java, C#, or Python.

About the author

Maur cio Aniche is a software engineer with 20 years of experience. He's also an Assistant Professor in Software Engineering at Delft University of Technology, and the author of Effective Software Testing.

Table of Contents

1 It's all about managing complexity
2 Making code small
3 Keeping objects consistent
4 Managing dependencies
5 Designing good abstractions
6 Handling external dependencies and infrastructure
7 Achieving modularization
8 Being pragmatic

• Format: Paperback
• Language: English
• ISBN: 163343799X
• ISBN13: 9781633437999
• Release Date: May 2024
• Publisher: Manning Publications
• Length: 192 Pages
• Weight: 0.75 lbs.
• Dimensions: 0.6" x 7.2" x 8.9"

Customer Reviews

The *WHY* of OO development explained!

This is a lucid explanation of very complex concepts involved in systematic design using interfaces. Chapter 2 on interface contracts was a revelation! We design interfaces and implement them, but what are the expectations between interfaces and their implementation? What covert contracts have to exist between them? As a developer exploring the OOP features of ActionScript 3.0, I really appreciated this book -- don't just...

VERY VERY HIGHLY RECOMMENDED!!

Are you a developer who has some experience with programming and who has been exposed to object-oriented design? If you are, then this book is for you. Author Ken Pugh, has done an outstanding job of writing a book that explores how developing software with an emphasis on interfaces helps you build robust systems easier and faster. Pugh, begins by looking at some code and textual interfaces. Then, the author looks at how...

Interface-Oriented Design

Very helpful introduction to Interface design. Examples are in C# but easily understandable by a VB programmer.

good introductory book

Too many beginning developers learning object oriented programming dive right into implementation and don't think about interfaces -- and interfaces are what OO is really all about. This book is a good introduction to designing and thinking about interfaces. It touches on these topics and more, with examples... The Three Laws of Interfaces: 1. An Interface's Implementation Shall Do What Its Methods Says It Does. (Principle...

A Successful and Worthwhile Book

I've been very pleased with Interface Oriented Design by Ken Pugh. Not only does it cover it's stated topic well, but it is also refreshing in two ways: one, at 215 pages it is just the right size for someone who needs an overview of the interface-oriented approach; and two, it operates at a level of abstraction that is paradigm-agnostic and time-proof. This book will be useful and relevant ten or fifteen years from now with...