101 Posts About Object-Oriented Programming (OOP)

Elegant Objects logoYou can learn more about OOP from my recently published book Elegant Objects too.

The Fall of JavaScript
The End of Type Annotations
remove(42) vs. find(42).remove()
Files.fileExists or file.exists?
Is Two-Step Initialization a Solution or a Symptom?
The Hidden Dangers of Method Overloading
Smaller Try-Blocks Are Better
Don't Group Exception Catchers
Declarative and Immutable Pipeline of Transformations
Reflection Means Hidden Coupling
Objectionary: Dictionary and Factory for EO Objects
Logging in Unit Tests, a Bad Practice
Prestructors
Dataization
Abstract Objects
Objects Without Methods
Strong Typing without Types
New Metric: the Distance of Coupling
Veil Objects to Replace DTOs
Prefixed Naming
Fat vs. Skinny Design
Object Cohesion: Why It Matters
How Much Cohesion Is Enough?
Date/Time Printing Can Be Elegant Too
How to Create a Java Web Framework from Scratch, the Right Object-Oriented Way
Logging Without a Static Logger
How Data Visibility Hurts Maintainability
Fear of Decoupling
Builders and Manipulators
What's Wrong With Global Variables?
Object Validation: to Defer or Not?
One More Recipe Against NULL
Fluent Interfaces Are Bad for Maintainability
Don't Parse, Use Parsing Objects
Operator new() is Toxic
SRP is a Hoax
DAO is Yet Another OOP Shame
Constructors or Static Factory Methods?
Yet Another Evil Suffix For Object Names: Client
RAII in Java
How I Would Re-design equals()
Object-Oriented Declarative Input/Output in Cactoos
Monikers Instead of Variables
How Does Inversion of Control Really Work?
SOLID Is OOP for Dummies
Traits and Mixins Are Not OOP
How to Handle the Problem of Too Many Classes
Each Private Static Method Is a Candidate for a New Class
Decorating Envelopes
Synchronized Decorators to Replace Thread-Safe Classes
Can Objects Be Friends?
MVC vs. OOP
EO
Encapsulation Covers Up Naked Data
OOP Without Classes?
Inheritance Is a Procedural Technique for Code Reuse
Gradients of Immutability
Vertical vs. Horizontal Decomposition of Responsibility
What's Wrong With Object-Oriented Programming?
If-Then-Else Is a Code Smell
ActiveRecord Is Even Worse Than ORM
The Law of Demeter Doesn't Mean One Dot
Who Is an Object?
Data Transfer Object Is a Shame
Singletons Must Die
Test Methods Must Share Nothing
Why InputStream Design Is Wrong
Object Behavior Must Not Be Configurable
Java Annotations Are a Big Mistake
Printers Instead of Getters
Try. Finally. If. Not. Null.
Design Patterns and Anti-Patterns, Love and Hate
Defensive Programming via Validating Decorators
Temporal Coupling Between Method Calls
Vertical and Horizontal Decorating
Redundant Variables Are Pure Evil
Why Many Return Statements Are a Bad Idea in OOP
Checked vs. Unchecked Exceptions: The Debate Is Not Over
Catch Me If You ... Can't Do Otherwise
Public Static Literals ... Are Not a Solution for Data Duplication
There Can Be Only One Primary Constructor
A Few Thoughts on Unit Test Scaffolding
Constructors Must Be Code-Free
Class Casting Is a Discriminating Anti-Pattern
Don't Create Objects That End With -ER
Composable Decorators vs. Imperative Utility Methods
Utility Classes Have Nothing to Do With Functional Programming
If. Then. Throw. Else. WTF?
A Compound Name Is a Code Smell
Immutable Objects Are Not Dumb
How Much Your Objects Encapsulate?
How an Immutable Object Can Have State and Behavior?
ORM Is an Offensive Anti-Pattern
Seven Virtues of a Good Object
How Immutability Helps
Dependency Injection Containers are Code Polluters
Getters/Setters. Evil. Period.
Anti-Patterns in OOP
Objects Should Be Immutable
Why NULL is Bad?
OOP Alternative to Utility Classes
sixnines availability badge  GitHub stars