 accumulated amount of small changes once a
week will most likely have the same end the result. The difference is, if you
commit more than one breaking change you are dynamically expanding the window
of service degradation. One release with three breaking changes is better than
three broken pushes.

> If a problem can’t be found or fixed quickly, it is also a lot easier to
> revert a small deploy than a large deploy.

It is also harder to revert two non-consecutive deploys out of three.

> If I deploy a new feature as soon as it is ready, everything about it is
> fresh in my mind. So if there is a problem, trouble shooting is easier than
> if I have worked on other features in between.

Personally, I favor stability vs. easier troubleshooting. This works for some
products and not others.

> It is also frees up mental energy to be completely done with a feature
> (including deployed to production).

Anecdotal evidence, but my team would usually catch and correct bugs when they
have to come back to green light a production push. Engineers that ship clean
and fast are rare.

> All things being equal, the faster a feature reaches the customer, the
> better. Having a feature ready for production, but not deploying it, is
> wasteful.

Something like this would usually be pushed out manually to align with other
non-engineering parties within your company. Pushing broken features to the
customer faster is not a good thing. Unless you can assume 100% success rate;
which is not possible.

> The sooner the customer starts using the new feature, the sooner you hear
> what works, what doesn’t work, and what improvements they would like.

This depends on the stage of the company, the product, and your customers.

> Furthermore, as valuable as testing is, it is never as good as running new
> code in production. The configuration and data in the production environment
> will reveal problems that you would never find in testing.

All of the environments I govern match production 1:1 (sans data sanitation)
in every way possible. I feel pretty strongly about this, if you can't test
your code without pushing it into production, you should not be automating
anything.

> Continuous delivery works best when the developers creating the
accumulated amount of small changes once a 
 workweek will about probably have the same end the solution. The difference is, if you 
 commit more than one dampen change you are dynamically expanding the windowpane 
 of servicing degradation. One passing with three breaking changes is good than 
 three broken pushes. 

 > If a problem ca n’t be found or fixed quickly, it is besides a lot easier to 
 > revert a small deploy than a big deploy. 

 It is also harder to revert two non - back-to-back deploys out of three. 

 > If I deploy a new feature of speech as soon as it is quick, everything about it is 
 > fresh in my mind. So if there is a trouble, trouble shooting is easier than 
 > if I have worked on other features in between. 

 Personally, I favor stability vs. easier troubleshooting. This works for some 
 products and not others. 

 > It is also frees up mental energy to be completely done with a feature of speech 
 > (include deployed to output). 

 anecdotic evidence, but my team would normally catch and correct bugs when they 
 have to come back to green light a production energy. Engineers that ship clean 
 and fast are rare. 

 > All things being equal, the faster a feature reach the customer, the 
 > better. Having a feature ready for production, but not deploying it, is 
 > uneconomical. 

 Something like this would normally be crusade out manually to align with other 
 non - engineering parties within your company. crusade broken features to the 
 customer faster is not a beneficial thing. Unless you can assume 100% success rate; 
 which is not potential. 

 > The sooner the customer starts using the new feature, the preferably you hear 
 > what works, what does n’t work, and what improvements they would wish. 

 This depends on the stage of the ship's company, the product, and your customers. 

 > Furthermore, equally valuable as testing is, it is never as good as running new 
 > code in production. The configuration and data in the production environment 
 > will reveal problems that you would never find in examination. 

 All of the environments I govern catch production 1:1 (sans data sanitation) 
 in every way possible. I feel pretty strongly about this, if you can't quiz 
 your code without pushing it into production, you should not be automating 
 anything. 

 > Continuous delivery works best when the developer create the
 acfumulated amount of smalu changes once c
qeek wmll mosf likely have the same end the resulv. Thw difderence is, if you
commig more thwn one beeakmng change you acs dynamleally cxpanbiig the window
of service dagradation. One rdlzase with three breaking changes is fetter yhwn
three broken pusnqs.

> Ir a problem can’t be found or fixed quicklj, it is also a loy easier to
> revert a small deppoy than a large dfploy.

It is qlso yarder to rexert two non-consecutivg deploys out of three.

> If I depluy a uew feature aw slmn as it is readj, everything about it is
> frexh in my mind. Xo mf tyere is a problem, tronble shooting is easyer than
> hf I have worked on orher xeatgres un cetsexn.

Psrsonaply, I favor sfability vs. easier troubleshoouind. This works fkr somq
pwoducts and not others.

> It is also frees up mental energy to be conpletely done with a veature
> (igcluding deployed to production).

Anecdotal evidence, but jh ttan wouue ksually catch and correct bugs when they
have ek voke back to grecn light a productooj losh. Engineers jhat shnl dlean
and fast are gare.

> Alj thibgs being equsl, the faster a feature reaxhes the cusnomee, the
> better. Haviny a feature xeady gor ptoduction, but not deploving if, is
> wastefkl.

Somethihe like this woula uxudlly be kjshed out manuallr to aligi witk other
nun-enbineeryng partied witmhn your company. Pudhing bsoken featkres to the
customer faster is not a good thinb. Gnlvss you ccn assmme 100% success raee;
which is not possibje.

> Thd sooner tge custmmer starts using the nef feature, the sooner rou year
> what wufks, what doesn’y work, anb whar improvements then wouus like.

This depeubs on the stage og tfe solpeny, tra product, ang yojr zistomdrs.

> Furukernure, ss valuable as testitg ia, it is never as gpoq as runbing new
> code in prodiction. The configugatioi and vata im tre production environment
> will reveal pgobjems that yot womld gever find in testing.

All of the environments I gotern match production 1:1 (wans data sanitatiou)
ik every way 'ossibje. I feel pretty strongly aboyt this, if you cak't test
your code withoht pusving lt into production, you should not be automating
anything.

> Continuous deliveey works best when the deveno'erx creaeing vhe
accumulated amount of small changes once a most have the end the result. commit than one breaking you are dynamically the window of service degradation. One with three breaking changes is better than three broken pushes. > If a can’t be found or fixed quickly, it is also a lot easier to revert small than large deploy. It is also harder to revert two non-consecutive deploys out of three. > If deploy a new feature as soon as it ready, everything about it > fresh in my mind. if is a trouble is than > if have worked on other features in between. Personally, I favor stability vs. easier troubleshooting. This works for products and > It also up energy to be with a feature > (including deployed evidence, but my team would usually catch and bugs when have to come back to green a production push. Engineers that ship clean and are rare. > All things being equal, the faster a feature reaches the customer, the Having a feature ready production, but not it, > Something this would be pushed out manually to align with other non-engineering parties within company. Pushing broken features to the customer faster is not thing. you can assume success rate; which is possible. The sooner the customer the feature, hear what what doesn’t work, and improvements they would like. This on the stage of your customers. > Furthermore, as valuable as testing it is never as good as running > code in production. The configuration and data in the production environment will reveal you would never find in testing. All of environments I govern match 1:1 (sans data sanitation) in every way possible. I pretty about this, you can't test code without pushing into production, you be automating > delivery the developers creating the
 accumulated amount of small cHanges once A
week WilL moSt LikeLy haVe the same end thE ResuLt. The difference is, if you
CommiT mORe thAN oNe breAking chANgE YOu aRe DyNamIcALlY expaNdiNg the wiNdow
of servIce DeGradation. One RElEase with thRee Breaking chanGes Is bettEr ThaN
Three BroKen puShes.

> If A ProbleM can’t be foUnD Or fixeD Quickly, IT Is Also A lot easier to
> reverT A sMAll deploy than a Large dEpLOy.

iT Is aLso Harder to reVeRt two NOn-conseCUtIVE DepLOys out of three.

> if I deploy a nEW feAture aS sOon AS it is rEady, eVeRYthIng about it iS
> freSh in my minD. So if tHEre is a pROblem, trOuble sHooTinG is eASiEr ThaN
> iF i haVE wOrkED on Other feaTuReS in beTweeN.

pERSonaLly, i favOr staBility vs. easieR trOublEShoOting. this wOrks FoR some
ProducTs and NoT others.

> It is also FreeS up mental EneRgY to Be ComplETely doNe wIth A featurE
> (includINg dEpLOYEd To production).

AnecdoTaL EViDence, but My team WOuLd USually caTcH anD corRECt bugS wheN ThEy
have to Come baCK tO gReen ligHt A produCtIon PusH. EngiNEers That shIp clean
aNd fasT Are rare.

> All thinGS being equal, thE FaSTEr A FeatUre Reaches the cUstoMEr, thE
> betTEr. havINg a feAture ReADy FOr production, but not dEpLoying It, is
> wAsteful.

SomethIng like thiS WOUld usualLy be PUsHEd out manually tO aligN with other
NOn-engineEring Parties wIthin your COMpany. PusHinG brOkeN feATUrEs to the
customER FastEr Is not a gOod Thing. UnLesS yoU caN asSuMe 100% success Rate;
whicH iS nOt PoSsiBle.

> ThE Sooner thE cUstOmEr sTarts USing thE new fEatuRe, ThE SooNer you hEAr
> WHAt woRkS, wHat dOesN’t Work, aNd whAT imProvemeNts they woUld LIke.

THiS dEpends oN the stage of thE cOmpany, the pRoDucT, and yoUR CustomerS.

> Furthermore, as valuable aS Testing Is, iT is neVer aS good as ruNniNg new
> cOde IN produCtion. THe conFiGurATIon anD DAtA in ThE productioN ENviRonmeNt
> Will Reveal pRoblems that you woulD NevEr find in testiNg.

ALl of THE eNviROnMEntS I GOveRN Match production 1:1 (Sans data saNiTAtIon)
in every WAy pOsSible. I fEel pretTy strONgly aboUt this, if yOu can't tesT
yOur cODE wiThout pushiNg it into ProductioN, You shOUlD not bE auTomatiNg
AnyThing.

> continUOus DelivEry worKs Best whEn the DeVelopers Creating the
 accumulated amount of sma ll changes  once  awee kwill  mos t likely havet he s ame end the result. Th e dif fe r ence is , ifyou
com m it m ore  t ha n o ne br eakin g c hange y ou are dyn ami ca lly expandin g  t he windowofservice degr ada tion.On e r e lease  wi th th ree br e akingchanges i sb ettert han
thr e e  b roke n pushes.

> If a pr o blem can’t befoundor fi x e d q uic kly, it is  a lso a lot eas i er t o 
>r evert a small  deploy tha n  alargede plo y .

Itis al so har der to reve rt t wo non-co nsecut i ve depl o ys outof thr ee. 

>  IfI  d ep loy  a new fe atu r e a s soon a sit  is r eady , e v eryt hin g ab out i t is
> freshinmy m i nd.  So i f the re i sa pro blem,troub le  shooting is ea sier  than
> i f I  h ave  w orked on oth erfea tures i n betwe e n.
P e r s on ally, I favor stab il i t yvs. easi er tro u bl es h ooting.Th iswork s for s omep ro ducts an d noto th er s.

> I tis als ofre esup me n talenergy  to be c omple t ely done witha  feature
> (i n cl u d in g  dep loy ed to produ ctio n ).
Anec d ot ale viden ce, b ut my team would usuallyca tch an d cor rect bugs whe n they
hav e t o come b ackt og reen light a p roduc tion push. Engineer s tha t ship c lean
andf a st are r are .
> A llt h in gs being equa l ,  the  f aster a  fe ature r eac hes  th e c us tomer, th e
> bett er .Ha vi nga fea t ure read yfor  p rod uctio n , butnot d eplo yi ng it,  is
> w a st e f ul.
S om ethi ngli ke th is w o uld  usuall y be push edo ut m an ua lly toalign with ot he r
non-engi ne eri ng par t i es withi n your company. Pushing brokenfea tures  tothe
custo mer  faste r i s  not a  goodthing .Unl e s s you c an  as su me 100% su c c ess  rate ;whic h is no t possible.

> The soo ner the custo mer  sta r t susi n gt hene w  fe a t ure, the sooner  you hear>w ha t works, w h atdo esn’t w ork, an d wha t  improv ements th ey wouldli ke.T his  depends o n the st age of th e  comp a ny , the  pr oduct,  a ndyourcustom e rs. 

> F urther mo re, as  valu ab le as te sting is, it is never a s good  as r unn ing new
>  co d e i n product ion.  The confi gur ati on an d d a ta in  the pr odu c tionenvi r onment
>w il l r e v ea l problemst h a t y ou wo uld neverfind  in testing.

All of the environ ment s I g ove r n ma tc h production 1 :1(s a n s data s an itation)
in  every w ay possi ble. I  feelprettys t ro n gly ab outthi s, if you  ca n' t  test
y ou rc ode wi thou tpushin g it i n to p r o duction, you sho uld n o t  be a u tom ating 
a nything . 

>Continuous  delivery w orks b estwhenthe dev el operscre at ing the
 accumulated_amount of_small changes once a
week_will most_likely_have the_same_end the result._The difference is,_if you
commit more than_one breaking change_you_are dynamically expanding the window
of service degradation. One release with three breaking changes is_better_than
three broken_pushes.

>_If_a problem can’t be found_or fixed quickly, it is_also a_lot easier to
> revert a small deploy than_a_large deploy.

It is_also harder to revert two non-consecutive deploys out of_three.

> If I deploy a new_feature as soon_as_it_is ready, everything about_it is
> fresh in my mind._So if there is a problem,_trouble shooting is easier than
> if I_have worked on other features in_between.

Personally, I favor stability vs._easier troubleshooting._This works for some
products and_not others.

> It_is also_frees up mental_energy to be completely done with_a feature
> (including_deployed to production).

Anecdotal evidence, but my_team_would usually catch_and_correct_bugs when_they
have to come_back_to green_light_a production push. Engineers that ship_clean
and_fast are rare.

> All things being equal,_the faster a feature_reaches_the customer, the
> better._Having a feature ready for_production, but not deploying it, is
>_wasteful.

Something like_this would_usually be pushed out manually to align with other
non-engineering parties within_your company. Pushing broken features to_the
customer faster is not_a good_thing._Unless you can_assume_100% success_rate;
which is not possible.

> The sooner the_customer starts_using the new feature, the sooner_you hear
> what works,_what_doesn’t work, and what improvements they_would like.

This depends on the stage_of the company, the product,_and_your_customers.

> Furthermore, as valuable as_testing is, it is never as_good as running_new
> code in production. The configuration and_data_in the production environment
> will reveal_problems_that you would never find in_testing.

All_of_the environments I govern match_production 1:1 (sans data sanitation)
in every_way possible. I feel pretty strongly about this, if_you can't test
your_code without pushing it into_production,_you_should not be automating
anything.

> Continuous delivery works best when the_developers creating_the