Easy to maintain code

Created by Jeroen De Dauw for Wikimedia Deutschland
Licensed CC BY-SA 3.0


Collection of pointers

We want to go fast

Tradable quality hypothesis

Write code for humans

Software craftsmanship


Reveal intent

usrsbscr ➜ userSubscription

Avoid disinformation

Use one word per concept

Don't try to be clever/cute


Cyclomatic complexity, NPath complexity

Minimize scope, minimize state

function onFirstPost() {
    $messageText = $this->getWelcomeMessageBody();
    if ($this->addFooter()) {
        $messageText.= $this->getWelcomeMessageFooter();

    foreach ($this->getReviewers() as $reviewer) {
        $this->reviewerNotifier->notify( $reviewer );

function onFirstPost() {


  • Small, few ELOC
  • One level of abstraction
  • Little nesting
  • Single functional area
  • Minimize parameters
  • Command query separation

public boolean set( String attributeName, String value );

if ( set( "username", "NyanCat" ) )

Minimize coupling

  • Number of classes bound to
  • Avoid inheritance
  • Program against "interfaces"

Avoid global state

public function doStuff() {
    FilesystemLogger::log( 'doing stuff on Caturday is madness' );
    DataStore::getInstance()->saveObject( $object );

function __construct( Logger $logger, DataStore $dataStore ) {
    $this->logger = $logger;
    $this->dataStore = $dataStore;

public function doStuff() {
    $this->logger->log( 'doing stuff on Caturday is madness' );
    $this->dataStore->saveObject( $object );


You Aren't Gonna Need It

  • cost of creation
  • cost of delay
  • cost of maintenance
  • cost of correction

Applies to features, not ease of modification

Simple design is not simple

I'm sorry I had to write you such a long letter,
but I did not have time to write you a short one

-- Blaise Pascal

SOLID principles

  • SRP: one responsibility per class
  • OCP: classes doing their job should not need change
  • LSP: able to provide a subtype instead of the type
  • ISP: client specific interfaces rather than general ones
  • DIP: program against "interfaces"

Design patterns

Reusable solution to common problem

Communication tool

Layered design

Source: The Clean Architecture, Robert C Martin


Testable code and good design go hand in hand

Avoid dogma


Transcend the rules