2016 wordcamp frankfurt - the secret sauce for writing reusable code

The Secret SauceWriting Reusable

CodeAlain Schlesser www.alainschlesser.comSoftware Engineer & WordPress Consultant @schlessera

http://www.brightnucleus.com/

http://www.twitter.com/schlessera/

The Secret Sauce For Writing 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/

https://2016.frankfurt.wordcamp.org/session/the-secret-sauce-for-writing-reusable-code/

https://www.alainschlesser.com/config-files-for-reusable-code/

https://www.alainschlesser.com/config-files-for-reusable-code/


About The Person In Front Of You

Born in LuxembourgLiving in GermanyWorking in the Cloud

Passionate about:Code quality, software architecture, bestpractices, principles, patterns, andeverything 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 CodeProblem:

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 {

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

= reusable code

= project-specific code

Mixed Code Types


The reusable class should completelyignore where it gets its business

logic from. It should act onwhatever 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; }

/** * @param string $name The name of the person to greet. */ public function greet( $name ) { $greeting = $this->config->get( 'greeting' ); printf( '%1$s %2$s!', $greeting, $name ); }}


class ReusableGreeter {



/** * @param string $name The name of the person to greet. */ public function greet( $name ) { $greeting = $this->config->get( 'greeting' ); printf( '%1$s %2$s!', $greeting, $name ); }} = reusable

code= project-specific code


Business-specific Code Config File

Confi

g Fil

e

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 [


];

= reusable code

= project-specific code

=>

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 {



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


Confi

g Fil

e

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 = [ 'greeting' => 'Hello',];

return [ 'Example' => [ 'Greeter' => [ 'ReusableGreeter' => $reusable_greeter; ], ],];

Prefix For Multiple Plugins


<?php

namespace Example\Greeter;

$config = ConfigFactory::create( __DIR__ . 'config/defaults.php' );

$plugin = new Plugin( $config->getSubConfig( __NAMESPACE__ ) );

$plugin->run();

Prefix For Multiple Plugins


Configs & Auto-wiring Injectioninterface DatabaseConfig extends ConfigInterface { }

class Database {

/** @var DatabaseConfig */ protected $config;

/** * @param DatabaseConfig $config The Config to use. */ public function __construct( DatabaseConfig $config ) { $this->config = $config; }}


Domain-Specific Language

Domain-specific language (noun):

a computer programming language of limitedexpressiveness focused on a particular domain.

- Martin Fowler, ThoughtWorks


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


Adapted Configs

Provide defaults and then override with different Configs …

• 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 Configurationsconfig/defaults.php

config/dt.php


Config Library

https://github.com/brightnucleus/config

My own library:

Alternatives:

https://github.com/symfony/configsymfony/config

https://github.com/zendframework/zend-configzendframework/zend-config

brightnucleus/config







https://github.com/symfony/config






https://github.com/zendframework/zend-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 EndI’m Alain Schlesser.

Follow me on twitter: @schlessera

Or visit my site:www.alainschlesser.com



