The Secret Sauce For Writing Reusable Code

The Secret Sauce
Writing Reusable Code
Alain Schlesser www.alainschlesser.com
Software Engineer & WordPress Consultant @schlessera

The Secret Sauce ForWriting Reusable Code – 4th September 2016– Alain Schlesser
NOTE:
This talk was held at WordCamp Frankfurt on Sep. 4, 2016.
There’s an (on-going) series of complimentary blog posts:
https://www.alainschlesser.com/config-files-for-reusable-code/

About The Person In Front Of You
Born in Luxembourg
Living in Germany
Working in the Cloud
Passionate about:
Code quality, software architecture, best
practices, principles, patterns, and
everything related.

What To Expect
1. General principle that makes
code reusable
2. Common way of
implementing this principle

The Problem With Reusable Code…

Object-oriented syntax in and
of itself does not make your
code reusable.

So We Need To Rearrange This…

…Into This

Design your code so that the
reusable parts and the project-
specific parts never intermingle.

This Easily Allows Us To Go From This…

…To This

Example Code
Problem:
We want to have a reusable
Greeter class that can show
different greetings in different
projects.*
* Silly example that can still fit on slides

class Greeter {
/**
* @param string $name The name of the person to greet.
*/
public function greet( $name ) {
printf( 'Hello %2$s!', $name );
}
}
Mixed Code Types

class Greeter {
/**
*/
printf( 'Hello %2$s!', $name );
}
}
= reusable code = project-specific code
Mixed Code Types

The reusable class should completely
ignore where it gets its business
logic from. It should act on
whatever gets passed to it.
à Injection

class ReusableGreeter {
/** @var ConfigInterface */
protected $config;
/**
* @param ConfigInterface $config The Config to use.
*/
public function __construct( ConfigInterface $config ) {
$this->config = $config;
}
/**
*/
$greeting = $this->config->get( 'greeting' );
printf( '%1$s %2$s!', $greeting, $name );
}
}

class ReusableGreeter {
protected $config;
/**
*/
}
/**
*/
$greeting = $this->config->get( 'greeting' );
printf( '%1$s %2$s!', $greeting, $name );
}
}

Business-specific Code à Config File
ConfigFile
Reusable Class
Business Logic

<?php
// We return a standard PHP array as a result of including
// this Config file.
return [
'greeting' => 'Hello',
];
Basic Config File

<?php
// We return a standard PHP array as a result of including
// this Config file.
return [
];
=>
Basic Config File

Immediate Benefits
• Separate files
• Injection
• Type-hinting
• Validation

Secondary Benefits
• Forced modularisation
• Tested code
• Collaboration

Source Is Flexible
As the source should be irrelevant for the
classes that use the Config data, you can
combine several files into one, read them
from a database or network, build them at
run-time for unit tests, etc…

<?php
// We can prefix a section of a Config, so that one file
// can be used for multiple classes.
return [
'ReusableGreeter' => [
],
];
Prefix For The Reusable Class

class Plugin {
protected $config;
/**
*/
}
public function run() {
$greeter = new ReusableGreeter(
$this->config->getSubConfig( 'ReusableGreeter' )
);
$greeter->greet( 'World' );
}
}

ConfigFile
Getting The Config File Into The Reusable Class
Reusable Class
Plugin ClassBusiness Logic
Business Logic
Business Logic

<?php
// We can prefix the entire Config, so that a single file
// can be shared across several plugins.
$reusable_greeter = [
];
return [
'Example' => [
'Greeter' => [
'ReusableGreeter' => $reusable_greeter;
],
],
];
Prefix For Multiple Plugins

<?php
namespace ExampleGreeter;
$config = ConfigFactory::create( __DIR__ . 'config/defaults.php' );
$plugin = new Plugin( $config->getSubConfig( __NAMESPACE__ ) );
$plugin->run();
Prefix For Multiple Plugins

Configs & Auto-wiring Injection
interface DatabaseConfig extends ConfigInterface { }
class Database {
/** @var DatabaseConfig */
protected $config;
/**
* @param DatabaseConfig $config The Config to use.
*/
public function __construct( DatabaseConfig $config ) {
}
}

Domain-Specific Language
Domain-specific language (noun):
a computer programming language of limited
expressiveness focused on a particular domain.
- Martin Fowler, ThoughtWorks

PHP Config ... Closures! ( = ~DSL )

Adapted Configs
Provide defaults and then overridewith differentConfigs …
• for different sites/apps (site_a.php)
• for different environments (site_a-development.php)
• for different contexts (unit-tests.php)
• for specific situations (run-backups.php)
• …

Site/App-specific Configurations
config/defaults.php
config/dt.php

Config Library
https://github.com/brightnucleus/config
My own library:
Alternatives:
https://github.com/symfony/config
symfony/config
https://github.com/zendframework/zend-config
zendframework/zend-config
brightnucleus/config

“Can You Summarize, Please?”
• Design for reusability from the get-go
• Have a clean separation between
different types of code
• Config files provide a structured way of
injecting project-specific logic into
reusable classes

The End
I’m Alain Schlesser.
Follow me on twitter:
@schlessera
Or visit my site:
www.alainschlesser.com

The Secret Sauce For Writing Reusable Code

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (19)

Similar to The Secret Sauce For Writing Reusable Code

Similar to The Secret Sauce For Writing Reusable Code (20)

Recently uploaded

Recently uploaded (20)

The Secret Sauce For Writing Reusable Code