In this repository, you will find many articles related to Software Design

• Coupling - The one and only software design problem

• Fail Fast

• How to Decouple a Legacy System

• How to Get Rid of Annoying IFs Forever

• Laziness I - Metaprogramming

• Laziness II - Code Wizards

• No Silver Bullet

• Nude Models - Part I: Setters

• Nude Models - Part II: Getters

• Null: The Billion Dollar Mistake

• Object Design Checklist

• Programming as Theory Building

• Singleton - The Root of All Evil

• The Evil Power of Mutants

• The One and Only Software Design Principle

• What Exactly Is a Name? Part I: The Quest

• What exactly is a name - Part II Rehab

• What is (wrong with) software?

• (Most) Programmers are losing our jobs very soon

• Maxi Contieri on Clean Code, Refactoring, and Test-Driven Development

• Reputation and Trust. Rely on Others

• Rethinking Leap Years: Why Your Favorite Programming Language's Approach May Be Flawed

• Satellites, Sovereignty, and the Next Internet Revolution

• Software Engineer Maxi Contieri on writing about "boring" fundamentals

• Warning: The Universe's Event Simulator Is a Fierce Adversary for Coders!

• 10 Pieces of Advice to Get your First Job from a Senior Interviewer

• 50 Fundamental Advices for Junior Developers

• Software Engineering Great Quotes

• How I Survived the Zombie Apocalypse

• How to Squeeze Test Driven Development on Legacy Systems

• We Should Get Rid of HelloWorld Forever

• How to Find the Stinky Parts of your Code

• Code Smell 01 - Anemic Models

• Code Smell 02 - Constants and Magic Numbers

• Code Smell 03 - Functions Are Too Long

• Code Smell 04 - String Abusers

• Code Smell 05 - Comment Abusers

• Code Smell 06 - Too Clever Programmer

• Code Smell 07 - Boolean Variables

• Code Smell 08 - Long Chains Of Collaborations

• Code Smell 09 - Dead Code

• Code Smell 10 - Too Many Arguments

• Code Smell 11 - Subclassification for Code Reuse

• Code Smell 12 - Null

• Code Smell 13 - Empty Constructors

• Code Smell 14 - God Objects

• Code Smell 15 - Missed Preconditions

• Code Smell 16 - Ripple Effect

• Code Smell 17 - Global Functions

• Code Smell 18 - Static Functions

• Code Smell 19 - Optional Arguments

• Code Smell 20 - Premature Optimization

• Code Smell 21 - Anonymous Functions Abusers

• Code Smell 22 - Helpers

• Code Smell 23 - Instance Type Checking

• Code Smell 24 - Boolean Coercions

• Code Smell 25 - Pattern Abusers

• Code Smell 26 - Exceptions Polluting

• Code Smell 27 - Associative Arrays

• Code Smell 28 - Setters

• Code Smell 29 - Settings / Configs

• Code Smell 30 - Mocking Business

• Code Smell 31 - Accidental Methods on Business Objects

• Code Smell 32 - Singletons

• Code Smell 33 - Abbreviations

• Code Smell 34 - Too Many Attributes

• Code Smell 35 - State as Properties

• Code Smell 36 - Switch/case/elseif/else/if statements

• Code Smell 37 - Protected Attributes

• Code Smell 38 - Abstract Names

• Code Smell 39 - new Date()

• Code Smell 40 - DTOs

• Code Smell 41 - Regular Expression Abusers

• Code Smell 42 - Warnings/Strict Mode Off

• Code Smell 43 - Concrete Classes Subclassified

• Code Smell 44 - Magic Corrections

• Code Smell 45 - Not Polymorphic

• Code Smell 46 - Repeated Code

• Code Smell 47 - Diagrams

• Code Smell 48 - Code Without Standards

• Code Smell 49 - Caches

• Code Smell 50 - Object Keys

• Code Smell 51 - Double Negatives

• Code Smell 52 - Fragile Tests

• Code Smell 53 - Explicit Iteration

• Code Smell 54 - Anchor Boats

• Code Smell 55 - Object Orgy

• Code Smell 56 - Preprocessors

• Code Smell 57 - Versioned Functions

• Code Smell 58 - Yo-yo Problem

• Code Smell 59 - Basic / Do Functions

• Code Smell 60 - Global Classes

• Code Smell 61 - Coupling to Classes

• Code Smell 62 - Flag Variables

• Code Smell 63 - Feature Envy

• Code Smell 64 - Inappropriate Intimacy

• Code Smell 65 - Variables Named after Types

• Code Smell 66 - Shotgun Surgery

• Code Smell 67 - Middle Man

• Code Smell 68 - Getters

• Code Smell 69 - Big Bang (JavaScript Ridiculous Castings)

• Code Smell 70 - Anemic Model Generators

• Code Smell 71 - Magic Floats Disguised as Decimals

• Code Smell 72 - Return Codes

• Code Smell 73 - Exceptions for Expected Cases

• Code Smell 74 - Empty Lines

• Code Smell 75 - Comments Inside a Method

• Code Smell 76 - Generic Assertions

• Code Smell 77 - Timestamps

• Code Smell 78 - Callback Hell

• Code Smell 79 - TheResult

• Code Smell 80 - Nested Try/Catch

• Code Smell 81 - Result

• Code Smell 82 - Tests Violating Encapsulation

• Code Smell 83 - Variables Reassignment

• Code Smell 84 - Max < Min (Javascript)

• Code Smell 85 - And Functions

• Code Smell 86 - Mutable Const Arrays

• Code Smell 87 - Inconsistent Parameters Sorting

• Code Smell 88 - Lazy Initialization

• Code Smell 89 - Math Feature Envy

• Code Smell 90 - Implementative Callback Events

• Code Smell 91 - Test Asserts without Description

• Code Smell 92 - Isolated Subclasses Names

• Code Smell 93 - Send me Anything

• Code Smell 94 - Too Many imports

• Code Smell 95 - Premature Classification

• Code Smell 96 - My Objects

• Code Smell 97 - Error Messages Without Empathy

• Code Smell 98 - Speling Mistakes

• Code Smell 99 - First Second

• Code Smell 100 - GoTo

• Code Smell 101 - Comparison Against Booleans

• Code Smell 102 - Arrow Code

• Code Smell 103 - Double Encapsulation

• Code Smell 104 - Assert True

• Code Smell 105 - Comedian Methods

• Code Smell 106 - Production Dependent Code

• Code Smell 107 - Variables Reuse

• Code Smell 108 - Float Assertions

• Code Smell 109 - Automatic Properties

• Code Smell 110 - Switches With Defaults

• Code Smell 111 - Modifying Collections While Traversing

• Code Smell 112 - Testing Private Methods

• Code Smell 113 - Data Naming

• Code Smell 114 - Empty Class

• Code Smell 115 - Return True

• Code Smell 116 - Variables Declared With 'var'

• Code Smell 117 - Unrealistic Data

• Code Smell 118 - Return False

• Code Smell 119 - Stairs Code

• Code Smell 120 - Sequential IDs

• Code Smell 121 - String Validations

• Code Smell 122 - Primitive Obsession

• Code Smell 123 - Mixed 'What' and 'How'

• Code Smell 124 - Divergent Change

• Code Smell 125 - 'IS-A' Relationship

• Code Smell 126 - Fake Null Object

• Code Smell 127 - Mutable Constants

• Code Smell 128 - Non-English Coding

• Code Smell 129 - Structural Optimizations

• Code Smell 130 - AddressImpl

• Code Smell 131 - Zero Argument Constructor

• Code Smell 132 - Exception Try Too Broad

• Code Smell 133 - Hardcoded IF Conditions

• Code Smell 134 - Specialized Business Collections

• Code Smell 135 - Interfaces With just One Realization

• Code Smell 136 - Classes With just One Subclass

• Code Smell 137 - Inheritance Tree Too Deep

• Code Smell 138 - Packages Dependency

• Code Smell 139 - Business Code in the User Interface

• Code Smell 140 - Short Circuit Evaluation

• Code Smell 141 - IEngine , AVehicle, ImplCar

• Code Smell 142 - Queries in Constructors

• Code Smell 143 - Data Clumps

• Code Smell 144 - Fungible Objects

• Code Smell 145 - Short Circuit Hack

• Code Smell 146 - Getter Comments

• Code Smell 147 - Too Many Methods

• Code Smell 148 - ToDos

• Code Smell 149 - Optional Chaining

• Code Smell 150 - Equal Comparison

• Code Smell 151 - Commented Code

• Code Smell 152 - Logical Comment

• Code Smell 153 - Too Long Names

• Code Smell 154 - Too Many Variables

• Code Smell 155 - Multiple Promises

• Code Smell 156 - Implicit Else

• Code Smell 157 - Balance at 0

• Code Smell 158 - Variables not Variable

• CoDe SmElL 159 - mIxEd_cASe

• Code Smell 160 - Invalid Id = 9999

• Code Smell 161 - Abstract/Final/Undefined Classes

• Code Smell 162 - Too Many Parentheses

• Code Smell 163 - Collection in Name

• Code Smell 164 - Mixed Indentations

• Code Smell 165 - Empty Exception Blocks

• Code Smell 166 - Low-Level Errors on User Interface

• Code Smell 167 - Hashing Comparison

• Code Smell 168 - Undocumented Decisions

• Code Smell 169 - Glued Methods

• Code Smell 170 - Refactor with Functional Changes

• Code Smell 171 - Plural Classes

• Code Smell 172 - Default Argument Values Not Last

• Code Smell 173 - Broken Windows

• Code Smell 174 - Class Name in Attributes

• Code Smell 175 - Changes Without Coverage

• Code Smell 176 - Changes in Essence

• Code Smell 177 - Missing Small Objects

• Code Smell 178 - Subsets Violation

• Code Smell 179 - Known Bugs

• Code Smell 180 - BitWise Optimizations

• Code Smell 181 - Nested Classes

• Code Smell 182 - Over Generalization

• Code Smell 183 - Obsolete Comments

• Code Smell 184 - Exception Arrow Code

• Code Smell 185 - Evil Regular Expressions

• Code Smell 186 - Hardcoded Business Conditions

• Code Smell 187 - If/Else Backwards

• Code Smell 188 - Redundant Parameter Names

• Code Smell 189 - Not Sanitized Input

• Code Smell 190 - Unnecessary Properties

• Code Smell 191 - Misplaced Responsibility

• Code Smell 192 - Optional Attributes

• Code Smell 193 - Switch Instead of Formula

• Code Smell 194 - Missing Interval

• Code Smell 195 - Yoda Conditions

• Code Smell 196 - Javascript Array Constructors

• Code Smell 197 - Gratuitous Context

• Code Smell 198 - Hidden Assumptions

• Code Smell 199 - Gratuitous Booleans

• Code Smell 200 - Poltergeist

• Code Smell 201 - Nested Ternaries

• Code Smell 202 - God Constant Class

• Code Smell 203 - Irrelevant Test Information

• Code Smell 204 - Tests Depending on Dates

• Code Smell 205 - Code in Destructors

• Code Smell 206 - Long Ternaries

• Code Smell 207 - Dynamic Methods

• Code Smell 208 - Null Island

• Code Smell 209 - Side Effects

• Code Smell 210 - Dynamic Properties

• Code Smell 211 - Tab over Spaces

• Code Smell 212 - Elvis Operator

• Code Smell 213 - Hoisting

• Code Smell 214 - Duplicate Parameter Names

• Code Smell 215 - Deserializing Object Vulnerability

• Code Smell 216 - Fat Interface

• Code Smell 217 - Empty Implementation

• Code Smell 218 - Magic Concatenation

• Code Smell 219 - Looping from index 0

• Code Smell 220 - Return Tuple

• Code Smell 221 - Missing Break in Switch

• Code Smell 222 - Comma Operator

• Code Smell 223 - Racial Naming

• Code Smell 224 - Deodorant Comments

• Code Smell 225 - Pass by Reference

• Code Smell 226 - Mixed Priorities

• Code Smell 227 - Cowboy Coding

• Code Smell 228 - Multiple Classes per File

• Code Smell 229 - Red Tape

• Code Smell 230 - Schrödinger Code

• Code Smell 231 - Redundant Data

• Code Smell 232 - Reusable Code

• Code Smell 233 - Collections Count

• Code Smell 234 - Long Circuit

• Code Smell 235 - Console Side Effects

• Code Smell 236 - Unwrapped Lines

• Code Smell 237 - Attribute Definitions

• Code Smell 238 - Entangled Code

• Code Smell 239 - Big Pull Request

• Code Smell 240 - Dead Store

• Code Smell 241 - Referential Transparency Violation

• Code Smell 242 - Zombie Feature Flags

• Code Smell 243 - Concatenated Properties

• Code Smell 244 - Incomplete Error information

• Code Smell 245 - exec() and eval()

• Code Smell 246 - Expiration Date

• Code Smell 247 - Javascript Replace

• Code Smell 248 - Unreliable Copy

• Code Smell 249 - Constants as Numbers

• Code Smell 250 - Premature Memoization

• Code Smell 251 - Collections Empty

• Code Smell 252 - NullCustomer

• Code Smell 253 - Silent Truncation

• Code Smell 254 - Mystery Guest

• Code Smell 255 - Parallel Hierarchies

• Code Smell 256 - Mutable Getters

• Code Smell 257 - Name With Collections

• Code Smell 258 - Secrets in Code

• Code Smell 259 - Testing with External Resources

• Code Smell 260 - Crowdstrike NULL

• Code Smell 261 - DigiCert Underscores

• Code Smell 262 - Not Replaced Constants

• Code Smell 263 - Squatting

• Code Smell 264 - Hanlon's Razor

• Code Smell 265 - Linguistic Confusion

• Code Smell 266 - Collection Aliasing

• Code Smell 267 - Objects Aliasing

• Code Smell 268 - Ternary Metaprogramming

• Code Smell 269 - Low-Level Addition

• Code Smell 270 - Boolean APIs

• Code Smell 271 - The Hollywood Principle

• Code Smell 272 - API Chain

• Code Smell 273 - Overengineering

• Code Smell 274 - Cascaded Returns

• Code Smell 275 - Missing Test Wrong Path

• Code Smell 276 - Untested Regular Expressions

• Code Smell 277 - UPPERCASE Acronyms

• Code Smell 278 - DirName and File

• Code Smell 279 - Loop Premature Optimization

• Code Smell 280 - Spaghetti Code

• Code Smell 281 - Hashes

• Code Smell 282 - Bad Defaults

• Code Smell 283 - Unresolved Meta Tags

• Code Smell 284 - Encrypted Functions

• Code Smell 285 - Non-Imperative Functions Names

• Code Smell 286 - Overlapping Methods

• Code Smell 287 - Unused Local Assignment

• Code Smell 288 - Unthrown Exceptions

• Code Smell 289 - Shy Visitor

• Code Smell 290 - Refused Bequest

• Code Smell 291 - Mutable Keys

• Code Smell 292 - Missing Return

• Code Smell 293 - isTesting

• Code Smell 294 - Implicit Return

• Code Smell 295 - String Concatenation

• Code Smell 296 - Unhappy to the Right

• Code Smell 297 - Syntactic Noise

• Code Smell 298 - Microsoft Windows Time Waste

• Code Smell 299 - Overloaded Test Setup

• Code Smell 300 - Package Hallucination

• Code Smell 301 - Database as Parameter

• Code Smell 302 - Misleading Status Codes

• Code Smell 303 - Breaking Changes

• Code Smell 304 - Null Pointer Exception

• Code Smell 305 - Null Infinity

• Code Smell 306 - AI External Comments

• Code Smell 307 - Naive Time Assumptions

• Code Smell 308 - Not Polymorphic Return

• Code Smell 309 - Query Parameter API Versioning

• Code Smell 310 - Vague Date Naming

• Code Smell 311 - Plain Text Passwords

• Code Smell 312 - Too Many Asserts

• Code Smell 313 - Workslop Code

• Content Structure: The Do's and Dont's of Content Creation

• The Complete Etiquette Guide to Writing #programming Articles on Hashnode

• The Reasons I Started Technical Blogging

• Today I Learned the Concept of Gardening

• Why I Create Content as a Developer and Teacher

• 5 Big Mistakes I Made Writing Technical Articles

• 10 Invaluable Tips for Successful Tech Articles

• 10 Tricks to Build an Awesome Personal Portfolio and Get Your Dream Job

• Top 10 Software Developer Self-Improvement Sites

• I Wrote More than 90 Articles on 2021 Here is What I Learned

• Mastering Atomic Habits

• My Best Short Productivity Tips

• What is JOMO and Why it will Increase your Productivity x97

• 10 More Simple Tips to Boost Your Productivity x2

• 16 Simple Tips to Boost Your Productivity x10

• The Tech Twitter Guide to the Galaxy

• Stop Calling them 'Bugs'

• 5 Programming Techniques to Avoid SSD Brick Catastrophic Failures

• Y2K22 - The Mistake That Embarrasses Us

• Conviertete en un Centauro del Codigo Limpio

• Programando un Wordle con TDD e Inteligencia Artificial

• Test Driven Development en Sistemas Heredados

• Test Driven Refactoring

• Una Regla para Gobernarlos a Todos

• Vibe Test Driven Development

• Test Driven Development 101

• GPT-3 Training Programmers for the Present (and the Future)

• ChatGPT is Amazing. And It is FREE

• Clean Code With AI

• DeepMind's AlphaCode Won't Steal Your Job Either

• From Helpful to Harmful: How AI Recommendations Destroyed My OS

• How to Detect Text Generated by Artificial Intelligence

• I Want to Build a Learning Companion for New Developers Using AI

• The Great Programmer Purge: How AI Is Taking Over the Tech Workforce

• Why GitHub Copilot is not a Threat to your Job

• I've Recently Learned About GPT3 - This is my Journey

• ChatGPT: The Surprising Teacher of a +25 Year Senior Programmer

• TDD Conference 2021 - Agile Pain Relief Through Technical Excellence - James Grenning

• TDD Conference 2021 - All Talks

• TDD Conference 2021 - Benefits Of Going Beyond The Make-It-Work Phase - Francisco Climent

• TDD Conference 2021 - GeePaw Hill - Want More Value Faster Take Many More Much Smaller Steps

• TDD Conference 2021 - How TDD sensitized me to speed as a regular workplace habit - Ragunath Jawahar

• TDD Conference 2021 - How To Get Started With Test-Driving Your Code - Jov Mit

• TDD Conference 2021 - Meenakshi Dhanani - Which is better to Code by Contract TDD or API-first

• TDD Conference 2021 - On The Relationship Between Units Of Isolation And Test Coupling - Mario Cervera

• TDD Conference 2021 - Opening Ceremony by Alex Bunardzic

• TDD Conference 2021 - Python - A Language Made For Test-Driven Development - Jan Giacomelli

• TDD Conference 2021 - TDD All The Things - Liz Keogh

• TDD Conference 2021 - TDD Manifesto - Daniel Moka

• TDD Conference 2021 - TDD Misconceptions - Olena Borzenko

• TDD Conference 2021 - Test-Driven Development on Legacy Systems - Maximiliano Contieri

• TDD Conference 2021 - Why I Love TDD And Why I'm Looking For Ways To Go Beyond TDD - Alex Bunardzic

• TDD Conference 2021 - Why You Might Not Want To Use TDD - Ola Kunysz

• How to Improve Your Code With Easy Refactorings

• Refactoring 001 - Remove Setters

• Refactoring 002 - Extract Method

• Refactoring 003 - Extract Constant

• Refactoring 004 - Remove Unhandled Exceptions

• Refactoring 005 - Replace Comment with Function Name

• Refactoring 006 - Rename Result Variables

• Refactoring 007 - Extract Class

• Refactoring 008 - Convert Variables to Constant

• Refactoring 009 - Protect Public Attributes

• Refactoring 010 - Extract Method Object

• Refactoring 011 - Replace Comments with Tests

• Refactoring 012 - Reify Associative Arrays

• Refactoring 013 - Remove Repeated Code

• Refactoring 014 - Remove IF

• Refactoring 015 - Remove NULL

• Refactoring 016 - Build With The Essence

• Refactoring 017 - Convert Attributes to Sets

• Refactoring 018 - Replace Singleton

• Refactoring 019 - Reify Email Addresses

• Refactoring 020 - Transform Static Functions

• Refactoring 021 - Remove Dead Code

• Refactoring 022 - Extract Common Ancestor

• Refactoring 023 - Replace Inheritance with Delegation

• Refactoring 024 - Replace Global Variables with Dependency Injection

• Refactoring 025 - Decompose Regular Expressions

• Refactoring 026 - Migrate Global Console Input to Declarative Function

• Refactoring 027 - Remove Getters

• Refactoring 028 - Replace Consecutive IDs with Dark Keys

• Refactoring 029 - Replace NULL With Collection

• Refactoring 030 - Inline Attributes

• Refactoring 031 - Removing OOPs

• Refactoring 032 - Apply Consistent Style Rules

• Refactoring 033 - Strip Annotations

• Refactoring 034 - Reify Parameters

• Refactoring 035 - Separate Exception Types

• How to Create a Wordle as a Centaur

• How to Create a Wordle with TDD in Javascript

• Step by Step Wordle Creation With Codex AI

• How to Develop a Wordle Game using TDD in 25 Minutes

• Web3 For Dummies - Part 01 - What is a Blockchain?

• Explain in 5 Levels of Difficulty

• Explain in 5 Levels of Difficulty: Bitcoin

• Explain in 5 Levels of Difficulty: ChatGPT

• Explain in 5 Levels of Difficulty: Ethereum

• Explain in 5 Levels of Difficulty: GIT

• Explain in 5 Levels of Difficulty: Linux

• Explain in 5 Levels of Difficulty: Object-Oriented Programming

• Explain in 5 Levels of Difficulty: Quantum Computing

• Explain in 5 Levels of Difficulty: The Fermi Paradox

• Explain in 5 Levels of Difficulty: Vibe Coding

• How a Hacker Stole $566M USD Exploiting a Code Smell

• How to Improve Software Quality, and reduce bugs in Startups

• Maxi Contieri Explains ChatGPT Revolution

• Maximiliano Contieri on Bridging the Industry-Academia Divide

• Software Design Videos

• Clean Code Cookbook is Out

• 3.2 Identifying the Essence of Your Objects

• 89 - Vibe Test Driven Development