automatic constraints as a team maturity accelerator for startups
Post on 16-Jan-2017
1.800 Views
Preview:
TRANSCRIPT
Automatic constraints as a team maturity accelerator for startups
Franccedilois-Guillaume
RIBREAUFGRibreau
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
LET ME TELL YOU A STORY
A growing startup
A growing startup
= a lot of newcomers = ever changing directions = need to move fast
[Where How What to follow] to start
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Franccedilois-Guillaume
RIBREAUFGRibreau
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
LET ME TELL YOU A STORY
A growing startup
A growing startup
= a lot of newcomers = ever changing directions = need to move fast
[Where How What to follow] to start
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
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
LET ME TELL YOU A STORY
A growing startup
A growing startup
= a lot of newcomers = ever changing directions = need to move fast
[Where How What to follow] to start
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
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
LET ME TELL YOU A STORY
A growing startup
A growing startup
= a lot of newcomers = ever changing directions = need to move fast
[Where How What to follow] to start
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Bringr
Developer oriented real-time monitoring and
administration service for Redis
LET ME TELL YOU A STORY
A growing startup
A growing startup
= a lot of newcomers = ever changing directions = need to move fast
[Where How What to follow] to start
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Developer oriented real-time monitoring and
administration service for Redis
LET ME TELL YOU A STORY
A growing startup
A growing startup
= a lot of newcomers = ever changing directions = need to move fast
[Where How What to follow] to start
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
LET ME TELL YOU A STORY
A growing startup
A growing startup
= a lot of newcomers = ever changing directions = need to move fast
[Where How What to follow] to start
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
A growing startup
A growing startup
= a lot of newcomers = ever changing directions = need to move fast
[Where How What to follow] to start
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
A growing startup
= a lot of newcomers = ever changing directions = need to move fast
[Where How What to follow] to start
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
[Where How What to follow] to start
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
- How to start alone a new project - Where are the conventions - What are the best practices - How can I quickly start on a new language - How to setup my dev env - How to deploy in production
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Only one quality guard
code reviews
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
PROBLEM
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
SOLUTION
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Letrsquos create conventions or how to add a new problem on top of another
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
httpbitly1iJ27GA
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
httpbitly1MmjFln
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
httpbitly1iJ2BfV
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
js best practices
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
java code-style httpbitly1G4rjvN
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Okay
So whatrsquos the workflow now
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
read conventions
write codeproduction
ready
memorise conventions
pass the code-review
Hard learning curve amp easy to forgot conventions
while writing code
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Humans are faillible
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
BACK TO SQUARE ONE
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Only one quality guard
code reviews
blabla
blabla
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
(
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Why not add tests tradeoff
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
)
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Even with conventions Itrsquos still hard to detect issues in code-reviews
- code-style - undefined variables - misused functions - wrong types - DRYSoC respect - security - project structure - file naming
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Does conventions mean scalability
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Nope
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
more feedbacks
production
more recruits
more code-reviews
human error
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
more code-reviews
more feedbacks
human error
production
production
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
It does not scale- learning curve is too hard - too hard for newcomers on other projects - conventions grow too fast - technology is moving faster than conventions
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
SOLUTION
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Dont rely on principle rely first on automation
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
AUTOMATE EVERYTHING
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Automate code-style checks
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
jscs
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
jscsrc
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
jscs
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Automate quality-checks with static-analysis
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
eslintrc
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Eslint
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Eslint
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Automate DRY-checks
with static-analysis
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
JSInspect
Match - 2 instances
- domainDateRangeIntervalValueObjectjs3537 + domainMeasurementQueryValueObjectjs205207 if (_isObject(req) || req || _isObject(reqquery)) return new PrettyError(400 Invalid request)
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
LETrsquoS INVENT
A NEW PRINCIPLE
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Still
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
- when amp how to run these checks - how to manage legacy code - how to talk about automated conventions - how and who choose conventions - how to be quickly up to speed with new projectsplatformlanguages
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
when amp how to run these checks
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
read conventions
write code production
memorise thempass
code review
before
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
write code production
pass the code review
CIautomated
checks
continuous checks
after
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Letrsquos introduce
check-build (for javascript)
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
httpbitly109XewR
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
5SecurityFres
hness
Code styleDRYness
SyntaxGoodPractices
JSInspect
DavidNsp
httpbitly109XewR
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
how to manage legacy code
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
PROBLEM
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Bringr
monolith
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
SOLUTION
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
First donrsquot feed the damn monolith
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Bringr
Bringr Strategy
BringrImpact
Bringr
BringrSourcing
Bringr
BringrAlerts
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Then only automate checks on new code
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Bringr Strategy Bringr Impact
Bringr Backend
Bringr Sourcing Bringr Account
Bringr Alerts
Filtering
Statistics
Rules EnginePublishing
Statistics Updater
UIUIUI
Indexing
G+
Vimeo
Youtube
Wordpres
Notifications
only automate new code
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
how to talk about automated conventions
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
PROBLEM
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Automating everything can sometimes means less readable conventions amp best practices
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
jscsrc
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
SOLUTION
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Generate readable documentation
from automated tools
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
write code production
pass the code review
CIautomated
checks
continuous checks
before
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
write code production
pass the code review
CI
continuous checks
after
readable convention
automated checks
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
jscsrcbefore
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
httpbitly1itmabjafter
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
httpbitly1itmabj
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
how and who choose conventions
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Conventions should be versioned
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Debates should be around
Pull-Requests
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
rdquoFGRibreau
ldquoDONrsquoT CREATE CONVENTIONS YOU CANrsquoT ENFORCE
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
how to be quickly up to speed with new projectsplatformlanguages
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
CI
check-build
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
centralize conventions
keep settings
DRY
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Still
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
You still need to explain the WHY
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
We record internal talks about why we do what we do
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
One last thing
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
These automated principles were about code
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
How to spread wider principles (eg application architecture)
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
stories2
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
FGRibreau
constants filesenvironme
nt variables
distributed
Simplicity Genericity
Knowing every running environments
One configuration to rule them all
CONFIGURATION
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
rdquoFGRibreau
ldquoEVERY CONSTANT NUMBER BOOLEAN OR STRING SHOULD BE CONFIGURABLE
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
How can we be sure developers will follow this principle
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Build base libraries Ease the learning curve Constrain by API design
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
microserviceAPI
documentation
API schema
API validation
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
swaggerjson-schemahapijson-api
(Pre-configured in a bootstrap project)
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
Everything we just saw makes a common base
- leads the developer mindset while coding - brings developers quickly up to speed - flatten issues to cross-language concerns - being able to capitalize on amp standardize issues with an adapted tooling is a huge win
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
What about non-code principles Eg github repository names
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
A cron checks every days repository names If a developer makes a mistake he will be notified
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
PRINCIPLES
CONVENTIONS
AUTOMATION
CONSTRAINTS
CODE
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
FGRibreau
QuestionsJoin us iAdvize
Donrsquot forget to take some stickers
Thank you
top related