135
@FGRibreau DEVELOPMENT PRINCIPLES & PHILOSOPHY

Development Principles & Philosophy

Embed Size (px)

Citation preview

FGRibreau

DEVELOPMENT PRINCIPLES

amp PHILOSOPHY

Franccedilois-Guillaume

RIBREAUFGRibreau

Bringr

BringrPerformance oriented

Social Media Management

BringrLeader europeacuteen de

lengagement client en temps reacuteel

(click2chat click2call click2video community )

sold

Bringr

Developer oriented real-time monitoring and

administration service for Redis

FGRibreau

COMPUTER SCIENCE IS ABOUT TRADEOFFS

FGRibreau

VSWHEN YOU FIGHT TO SURVIVE

BETTER CHOOSE THE RIGHT PATH

FGRibreau

How can I make the right choice

while coding

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

Franccedilois-Guillaume

RIBREAUFGRibreau

Bringr

BringrPerformance oriented

Social Media Management

BringrLeader europeacuteen de

lengagement client en temps reacuteel

(click2chat click2call click2video community )

sold

Bringr

Developer oriented real-time monitoring and

administration service for Redis

FGRibreau

COMPUTER SCIENCE IS ABOUT TRADEOFFS

FGRibreau

VSWHEN YOU FIGHT TO SURVIVE

BETTER CHOOSE THE RIGHT PATH

FGRibreau

How can I make the right choice

while coding

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

Bringr

BringrPerformance oriented

Social Media Management

BringrLeader europeacuteen de

lengagement client en temps reacuteel

(click2chat click2call click2video community )

sold

Bringr

Developer oriented real-time monitoring and

administration service for Redis

FGRibreau

COMPUTER SCIENCE IS ABOUT TRADEOFFS

FGRibreau

VSWHEN YOU FIGHT TO SURVIVE

BETTER CHOOSE THE RIGHT PATH

FGRibreau

How can I make the right choice

while coding

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

BringrPerformance oriented

Social Media Management

BringrLeader europeacuteen de

lengagement client en temps reacuteel

(click2chat click2call click2video community )

sold

Bringr

Developer oriented real-time monitoring and

administration service for Redis

FGRibreau

COMPUTER SCIENCE IS ABOUT TRADEOFFS

FGRibreau

VSWHEN YOU FIGHT TO SURVIVE

BETTER CHOOSE THE RIGHT PATH

FGRibreau

How can I make the right choice

while coding

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

BringrLeader europeacuteen de

lengagement client en temps reacuteel

(click2chat click2call click2video community )

sold

Bringr

Developer oriented real-time monitoring and

administration service for Redis

FGRibreau

COMPUTER SCIENCE IS ABOUT TRADEOFFS

FGRibreau

VSWHEN YOU FIGHT TO SURVIVE

BETTER CHOOSE THE RIGHT PATH

FGRibreau

How can I make the right choice

while coding

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

Bringr

Developer oriented real-time monitoring and

administration service for Redis

FGRibreau

COMPUTER SCIENCE IS ABOUT TRADEOFFS

FGRibreau

VSWHEN YOU FIGHT TO SURVIVE

BETTER CHOOSE THE RIGHT PATH

FGRibreau

How can I make the right choice

while coding

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

Developer oriented real-time monitoring and

administration service for Redis

FGRibreau

COMPUTER SCIENCE IS ABOUT TRADEOFFS

FGRibreau

VSWHEN YOU FIGHT TO SURVIVE

BETTER CHOOSE THE RIGHT PATH

FGRibreau

How can I make the right choice

while coding

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

COMPUTER SCIENCE IS ABOUT TRADEOFFS

FGRibreau

VSWHEN YOU FIGHT TO SURVIVE

BETTER CHOOSE THE RIGHT PATH

FGRibreau

How can I make the right choice

while coding

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

VSWHEN YOU FIGHT TO SURVIVE

BETTER CHOOSE THE RIGHT PATH

FGRibreau

How can I make the right choice

while coding

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

How can I make the right choice

while coding

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

EASY

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

FOLLOW AND DISCOVER

PRINCIPLES

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

SEPARATION OF CONCERNS

FGRibreau

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

SEPARATION OF CONCERNS

FGRibreau

AKA THINK ABOUT ____ROLES

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

MONOLITH(S)

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

Bringr

monolith

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

Use the Separation of Concerns Luke

Morpheus (not sure about this one)

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

Bringr

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

Bringr Strategy

BringrImpact

Bringr

BringrSourcing

Bringr

BringrAlerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

Bringr Strategy Bringr Impact

Bringr Backend

Bringr Sourcing Bringr Account

Bringr Alerts

Filtering

Statistics

Rules EnginePublishing

Statistics Updater

UIUIUI

Indexing

G+

Vimeo

Facebook

Youtube

Wordpress

Twitter

Notifications

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

MICROSERVICE TYPE DEFINITION

ACTIVE ACT ON SOMETHING

PASSIVE REACT TO SOMETHING

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

MICROSERVICE TYPE eg IN THE ASYNC WORLD

ACTIVE PUBLISHER

PASSIVE CONSUMER

AMQP RabbitMQ

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

THE LESS ACTIVE ONES THE BETTER

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

THE LESS ACTIVE ONES THE BETTER

THE MORE PASSIVE ONES THE BETTER

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES MICROSERVICES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGICINSIDE MICROSERVICES COMPONENTS

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

My Worker My Worker My Worker

State Repository

atomic

concurrency resilient scaleOut

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

State Repository

parallelism resilient scaleOut

State Repository

My Worker A My Worker B

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

clear contracts

easierscaling

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

EACH MICROSERVICE SHOULDHAVE ITS OWN RESPONSIBILITY

limit bug domain

improvedvelocity

clear contracts

easierscaling

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoFAIL FAST FAIL OFTEN

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

crash process as soon as possible

log errors

restart process

alert developer

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

(NodeJS) process

ramcpu IO

OS

fail fast fail often

CPU RAM and IO are limitedNodeJS process canrsquot always monitor himself

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

WE DO WANTCONSTRAINTS

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

WE DO WANTCONSTRAINTSNo more than 90 CPU during X mins

No more than 512Mo of RAM during X mins

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

LETrsquoS ADD ANOTHER PRINCIPLE

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

NodeJS process

ramcpu IO

OS

fail fast fail often

Supervisor

limited in space amp time

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

NodeJS process

dev staging prod

CONFIGURATION MANAGEMENT

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

13 configjsmoduleexports13 =13 function()13 13 13 13 switch(processenvNODE_ENV)13 13 13 13 13 13 13 13 case13 development13 13 13 13 13 13 13 13 13 13 13 13 return13 dev13 setting

13 13 13 13 13 13 13 13 case13 production13 13 13 13 13 13 13 13 13 13 13 13 return13 prod13 settings

13 13 13 13 13 13 13 13 default13 13 13 13 13 13 13 13 13 13 13 13 return13 error13 or13 other13 settings13 13 13 13

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

appconfigure(development13 function()13 13 appset(configPath13 confLocal)13 13 13 ldquoconfLocalrdquo13 is13 a13 constant)

appconfigure(production13 function()13 13 appset(configPath13 confProduction)13 13 ldquoconfProductionrdquo13 is13 a13 constant)

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

NodeJS process

dev staging prod

SHOULD MY PROCESS KNOW ITS OWN CONFIGURATION

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

NOPE

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

constants files environmentvariables distributed

CONFIGURATION

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

constants files environmentvariables distributed

Simplicity Genericity

Knowing every running environments

One configuration to rule them all

CONFIGURATION

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

var env = require(common-env)(logger)var config = envgetOrElseAll( amqp login guest password guest host localhost port 5672 reconnect false )

var conn = require(amqp)createConnection(configamqp)

AMQP_LOGIN=user AMQP_PASSWORD=azerty node serverjs

npm install common-env

httpsgithubcomFGRibreaucommon-env

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

NodeJS processLauncher

SoC FTW

env vars

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

But my cloud provider uses AMQP_ADDON_LOGIN

what should I do

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

var config = envgetOrElseAll( amqp addon login guest password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqpaddon)

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

NOPE

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

NodeJS processLauncher

SoC

env vars

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

NodeJS processLauncher

SoC

env vars

Internal code is dependent from

external naming convention

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

var config = envgetOrElseAll( amqp login $default guest $aliases [AMQP_ADDON_LOGIN] password guest host localhost port 5672 reconnect false )

var conn = amqpcreateConnection(configamqp)

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

configjsvar logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

appjsvar config = require(config)

srcmyownmodulejsvar config = require(config)

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

Does it respect

SoC

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

NOPE

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

var logger = require(my-logger)createLogger()var env = require(common-env)(logger)moduleexports = envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

config now asks for loggermoduleexports = function (logger) var env = require(common-env)(logger) return envgetOrElseAll( amqp login guest )

configjs

caller must specify logger to use config appjsvar logger = require(my-logger)createLogger()var config = require(config)(logger)

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

HUM I THINK I KNOW THIS PRINCIPLE

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

DEPENDENCY INVERSION

This is the D from SOLID

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

AGAIN

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

appjsvar config = require(config)(logger)

srcmyownmodulejsvar config = require(config)(logger)

DI DRY

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

appjsvar config = require(config)(logger)

srcmyownmodulejsmoduleexports = function (config)

DI DRY

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

HUM LET CREATE USA REMINDER

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

LETrsquoS TALK ABOUT CRON

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

YOU

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

CRON

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

CRON

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

USERS

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

CRON IS NOT WORKING ANYMORE

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

YOU

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

Process (eg cron)

ramcpu IO

OS

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

server

Process (eg cron)

ramcpu IO

OS

Supervisor

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

ITrsquoS ALL ABOUT TRADEOFFS

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

LETrsquoS INVENT

A NEW PRINCIPLE

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

NOTIFICATIONS

ALERTS=

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

OKLETrsquoS RECAP

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoDIVIDE MICROSERVICES BETWEEN ACTIVE AND

PASSIVE ONES

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoDIVIDE STATE AND LOGIC

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoEVERYTHING SHOULD BE LIMITED IN BOTH

SPACE amp TIME

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING

SHOULD BE CONFIGURABLE

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquordquoldquo IS A CODE SMELL

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoI SHOULD ALWAYS BE PROACTIVELY ALERTED

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquo[add your own]

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

THE MOST IMPORTANT PRINCIPLE BEING

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

SEPARATION of

CONCERNS

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

LETrsquoS GO FURTHER

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

PRINCIPLECode dependencies should

always be up-to-date

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

AUTOMATIONBuild should break if code dependencies are

not up-to-date

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

PRINCIPLECode style should

always be consistent

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

AUTOMATIONRun a style-checker at each build

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

PRINCIPLEEvery developers should follow DRY

(Donrsquot Repeat Yourself)

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

AUTOMATIONRun a structural code similarities tool

at each build

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

HERE IS WHAT

WE DID

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreauhttpsgithubcomFGRibreaucheck-build

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

ONE LAST THING

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

rdquoFGRibreau

ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoTENFORCE

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

PRINCIPLES

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

PRINCIPLESCONSTRAINTS

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

PRINCIPLES

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

FGRibreau

PRINCIPLES

CONVENTIONS

AUTOMATION

CONSTRAINTS

CODE

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you

Follow me FGRibreau

QuestionsJoin us iAdvize

Thank you