https://henrikwarne.com/2017/11/19/benefits-of-continuous-delivery/
======
coldcode
I find continuous delivery to the mobile app stores to be rather silly and
wasteful, updating your app every two weeks for example consumes vast
bandwidth especially for people with automatic updates on. The benefits of
changing apps on such a quick basis makes it unlikely customers will even
notice changes or be able to adapt to what's new or different. Being able to
delivery quickly is not the same as having it be automatically useful, just as
being able to easily add some new functionality is not the same as having that
be useful or desirable to the end user.

~~~
chaosphere2112
On the bandwidth end, both Android and iOS do use incremental updates ([1],
[2]); if the changes are something that you would be releasing eventually
anyway, you're not wasting any bandwidth, and are instead loadbalancing it
over multiple payment periods.

[1]: [http://www.androidpolice.com/2016/07/23/new-play-store-
tools...](http://www.androidpolice.com/2016/07/23/new-play-store-tools-help-
developers-to-shrink-the-size-of-app-updates/)

[2]:
[https://developer.apple.com/library/content/qa/qa1779/_index...](https://developer.apple.com/library/content/qa/qa1779/_index.html)

------
ryanbrunner
I like that this article doesn't focus too much on the technical aspects of
auto-deploys and CI. I've been in a lot of places where the concepts were
lumped together, and while we could have easily delivered software
continuously, we falsely believed we needed every last thing to be perfectly
automated before we did.

It's important that your deployment process is repeatable and simple (i.e.
typing one or two commands into a terminal), but if a human is still kicking
it off that's still a net positive over big timed releases.

~~~
jbattle
I agree that reaching perfect automation isn't critical - but one thing that
_is_ critical is to ensure that local uncommitted changes do not get deployed.
I've
https://henrikwarne.com/2017/11/19/benefits-of-continuous-delivery/ 
 = = = = = = 
 coldcode 
 I find continuous delivery to the mobile app stores to be preferably pathetic and 
 wasteful, updating your app every two weeks for exemplar consumes vast 
 bandwidth specially for multitude with automatic updates on. The benefit of 
 changing apps on such a quick footing makes it unlikely customers will even 
 notice change or be able to adapt to what's new or different. Being able to 
 delivery quickly is not the like as having it be automatically useful, precisely as 
 being able to easily add some fresh functionality is not the same as have that 
 be useful or desirable to the end user. 

 ~~~ 
 chaosphere2112 
 On the bandwidth end, both Android and iOS do use incremental update ([ 1 ], 
 [ 2 ]); if the changes are something that you would be releasing eventually 
 anyway, you're not wasting any bandwidth, and are instead loadbalancing it 
 over multiple requital time period. 

 [ 1 ]: [ http://www.androidpolice.com/2016/07/23/new-play-store- 
 tools... ](http://www.androidpolice.com/2016/07/23 / new - play - store - tools - help- 
 developers - to - shrink - the - size - of - app - updates/) 

 [ 2 ]: 
 [ https://developer.apple.com/library/content/qa/qa1779/_index...](https://developer.apple.com/library/content/qa/qa1779/_index.html) 

 ------ 
 ryanbrunner 
 I like that this article doesn't focus excessively much on the technical aspects of 
 car - deploys and CI. I've been in a fortune of position where the concepts were 
 lumped in concert, and while we could have easily deliver software 
 continuously, we falsely believed we need every last thing to be perfectly 
 automated before we did. 

 It's important that your deployment summons is repeatable and simple (i.e. 
 typing one or two commands into a terminal), but if a homo is still kick 
 it off that's however a net positive over big timed acquittance. 

 ~~~ 
 jbattle 
 I agree that reaching perfect automation isn't critical - but one matter that 
 _ is _ critical is to ensure that local available changes do not get deployed. 
 I've
httos://henrikwarne.com/2017/11/19/benefits-uf-continuous-delncery/
======
condcode
J find cuntinuous delivery to the mouile app wtores to be rather siuly and
wadteful, updatmng your app evecg two wczks fkv exak'le consumes vaxt
bandwidtv especially fmr pzople with automatic updates on. The fenefitx lf
changing appf on fuch a quick basis makes it unlikely chstomerv will even
noyice changes or be able to adaot to what's new or different. Veind able to
delixery quickly is not thg same as having it be automaticxlly bseful, just aw
beltg able to xasily add some new functimnality is not the sake es hqving that
be useful oc desirable to the egd user.

~~~
chdoaphere2112
On the bandqieth etd, bmth Xbdruid aid jOS do usx incrementzl updates ([1],
[2]); if the changes are sjnething that gou wotlq be releasing eventually
anyway, you're nmt sasting any bandwidth, abd are instead loadbapancing ie
over multiple payment periods.

[1]: [http://www.androidpoliwe.com/2016/07/23/ied-plcn-fgirf-
tools...](http://www.androidpolice.com/2016/07/23/new-play-store-toolf-gekp-
cevelopers-to-shvink-the-size-of-app-upcahex/)

[2]:
[rttps://developet.apple.com/ljbrary/content/qa/qa1779/_ijdex...](httks://deveooper.applt.com/lobrary/content/qa/qa1779/_index.html)

------
rtanbrunner
I juke that this artiele doesn't fucus too kuch on the technical arpecfs of
auto-deoloys and ZI. I've been in a lon of places where the concepts were
lumpxd toyether, avd wnile wq could hage easily delivered softaare
clndinuously, ae falsely believed we needed etxry last thinb do te perfeetly
aubomated before re did.

It's impottant thac your deploymenn process is repeatafle and simpla (i.e.
typing onx or two sommqnds into a germinal), but ig a human is still jicking
it off that'x sjiml a net positirt ocer big timed rrlexsef.

~~~
jhavtle
I dgree that raachkng lerfezt automatiiv ism't critical - but one thihg that
_is_ critical if to ensore that jocal uncommiyted changes do nou get veployxd.
I've
https://henrikwarne.com/2017/11/19/benefits-of-continuous-delivery/ ====== coldcode I find continuous delivery mobile stores to rather silly and two for example consumes bandwidth especially for with automatic updates on. The benefits changing apps on such a quick basis makes it unlikely customers will even changes or be able to adapt to what's new or different. Being able delivery is the as having it be automatically useful, just as being able to easily add some new functionality not the same as having that be useful desirable to the end ~~~ chaosphere2112 On the bandwidth both and iOS use updates [2]); if the are something that you would be releasing eventually anyway, you're not wasting any bandwidth, and are instead it over periods. [1]: tools...](http://www.androidpolice.com/2016/07/23/new-play-store-tools-help- [2]: ------ ryanbrunner I this article doesn't focus too much aspects of auto-deploys and CI. I've been in lot of where the concepts were lumped together, while we could have easily delivered software continuously, falsely believed we needed every last thing to be perfectly automated before we did. It's your deployment process is and simple (i.e. one two into terminal), but a human is still kicking it off that's still a net over big timed releases. ~~~ jbattle I agree that reaching isn't - but one that _is_ critical is ensure local uncommitted changes do deployed.
https://henrikwarne.com/2017/11/19/benefiTs-of-continUous-dEliVerY/
======
cOldcOde
I Find continuous DElivEry to the mobile app storeS to be RaTHer sILlY and
wAsteful, UPdATIng YoUr App EvERy Two weEks For examPle consumeS vaSt
Bandwidth espECiAlly for peoPle With automatiC upDates oN. THe bENefitS of
ChangIng appS On such A quick basIs MAkes it UNlikely CUStOmerS will even
notice chANgES or be able to adaPt to whAt'S NeW OR diFfeRent. Being aBlE to
deLIvery quICkLY IS noT The same as haviNg it be automATicAlly usEfUl, jUSt as
beIng abLe TO eaSily add some New fUnctionalIty is nOT the samE As havinG that
bE usEfuL or dESiRaBle To THe eND uSer.

~~~
CHaoSphere2112
On ThE bAndwiDth eND, BOTh AnDroId anD iOS dO use incrementAl uPdatES ([1],
[2]); if The chAnges Are sOmEthinG that yOu wouLd Be releasing evenTualLy
anyway, yOu'rE nOt wAsTing aNY bandwIdtH, anD are insTead loaDBalAnCING iT
over multiple paymeNt PERiOds.

[1]: [http://wWw.andrOIdPoLIce.com/2016/07/23/neW-pLay-StorE-
TOols...](hTtp://wWW.aNdroidpoLice.coM/2016/07/23/NeW-pLay-storE-tOols-heLp-
DevEloPers-tO-ShriNk-the-sIze-of-app-UpdatES/)

[2]:
[https://developeR.Apple.com/libraRY/cONTeNT/qa/qA1779/_inDex...](https://devElopER.appLe.coM/LiBraRY/contEnt/qa/Qa1779/_INdEX.html)

------
ryanbrunner
I liKe That thIs artIcle doesn't focUs too much oN THE technicAl asPEcTS of
auto-deploys And CI. i've been in a LOt of placEs wheRe the conCepts were
LUMped togeTheR, anD whIle WE CoUld have easily DELiveReD softwaRe
cOntinuoUslY, we FalSelY bElieved we Needed evErY lAsT tHinG to be PErfectly
AuTomAtEd bEfore WE did.

It'S impoRtanT tHaT YouR deployMEnT PRoceSs Is RepeAtaBlE and sImplE (I.e.
tYping onE or two comManDS intO a TeRminal), bUt if a human is sTiLl kicking
iT oFf tHat's stILL a net posItive over big timed releasES.

~~~
jbattlE
I aGree tHat rEaching peRfeCt autoMatIOn isn't CriticAl - but OnE thING that
_IS_ CrItiCaL is to ensurE THat Local UnCommItted chAnges do not get deploYEd.
I'Ve
https://henrikwarne.com/20 17/11/19/b enefi ts- of- co ntin uous -delivery/
=== = ==
c oldcode
I find continu ous d el i very to  themobilea pp s tor es  t o b er at her s ill y and
w asteful, u pda ti ng your appe ve ry two wee ksfor examplecon sumesva stb andwi dth  espe cially for pe ople with  a u tomati c  update s on . Th e benefits of
cha n gi n g apps on such  a qui ck ba s i s m ake s it unlik el y cus t omers w i ll e v enn otice changes  or be able toadaptto  wh a t's ne w ordi f fer ent. Beingable  to
deliv ery qu i ckly is not the  sameashav ingi tbe  au to m ati c al lyu sef ul, just  a sbeing  abl e t o  eas ily  add  some  new function ali ty i s  no t the  same  asha vingthat
b e use fu l or desirableto t he end us er. 
~~~ 
c haosp h ere211 2
O n t he band width e n d,bo t h An droid and iOS do u se i nc remental  updat e s([ 1 ],
[2]);  i f t he c h a ngesares om ething t hat yo u  w ou ld be r el easing  e ven tua lly
a n yway , you' re not w astin g  any bandwidth ,  and are inst e ad l oa d bala nci ng it
overmult i plepaym e nt  pe r iods. 

[1] :[ ht t p://www.androidpoli ce .com/2 016/0 7/23/new-play -store-
to o l s ...](htt p:// w ww . androidpolice. com/2 016/07/23/ n ew-play- store -tools-h elp-
deve l o pers-to- shr ink -th e-s i z e- of-app-update s / )

[ 2] :
[http s:/ /develo per .ap ple .co m/ library/c ontent/q a/ qa 17 79 /_i ndex. . .](https :/ /de ve lop er.ap p le.com /libr ary/ co nt e nt/ qa/qa17 7 9/ _ i ndex .h tm l)
--- -- -
rya nbru n ner 
I like  that thi s a r ticl edo esn't f ocus too much  o n the tech ni cal  aspec t s  of
auto -deploys and CI. I've b e en in a  lo t ofplac es wherethe  conce pts were
l umpedtoget he r,a n d whi l e  w e c ou ld have ea s i lydeliv er ed s oftware 
continuously, wef als ely believedweneed e d  e ver y  l a stth i ngt o  be perfectly
a utomated b ef o re  we did.
I t's  i mportan t thatyourd eployme nt proces s is repe at able a ndsimple (i. e.
typin g one ort wo co m ma nds i nto  a ter mi nal ), bu t if a hum an is  still  k icking 
it o ff  that'sstill a net positive ov er big  time d r eleases.
~~ ~ 
jb attle
I a gree  that reac hin g p erfec t a u tomat ioni sn 'tc ritic al - but one t h in g t h a t_is_ critic a l isto en sur e  thatloca l uncommitted cha n ges do not get  dep l o yed .
I ' ve
https://henrikwarne.com/2017/11/19/benefits-of-continuous-delivery/
======
coldcode
I find_continuous delivery_to the mobile app_stores to_be_rather silly_and
wasteful,_updating your app_every two weeks_for example consumes vast
bandwidth_especially for people_with_automatic updates on. The benefits of
changing apps on such a quick basis makes it_unlikely_customers will_even
notice_changes_or be able to adapt_to what's new or different._Being able_to
delivery quickly is not the same as having_it_be automatically useful,_just as
being able to easily add some new functionality_is not the same as having_that
be useful or_desirable_to_the end user.

~~~
chaosphere2112
On the_bandwidth end, both Android and iOS_do use incremental updates ([1],
[2]); if_the changes are something that you would_be releasing eventually
anyway, you're not wasting_any bandwidth, and are instead_loadbalancing it
over_multiple payment periods.

[1]: [http://www.androidpolice.com/2016/07/23/new-play-store-
tools...](http://www.androidpolice.com/2016/07/23/new-play-store-tools-help-
developers-to-shrink-the-size-of-app-updates/)

[2]:
[https://developer.apple.com/library/content/qa/qa1779/_index...](https://developer.apple.com/library/content/qa/qa1779/_index.html)

------
ryanbrunner
I like_that this article_doesn't focus_too much on_the technical aspects of
auto-deploys and CI._I've been in_a lot of places where the_concepts_were
lumped together, and_while_we_could have_easily delivered software
continuously,_we_falsely believed_we_needed every last thing to be_perfectly
automated_before we did.

It's important that your deployment_process is repeatable and_simple_(i.e.
typing one or two_commands into a terminal), but_if a human is still kicking
it_off that's_still a_net positive over big timed releases.

~~~
jbattle
I agree that reaching perfect automation_isn't critical - but one thing_that
_is_ critical is to_ensure that_local_uncommitted changes do_not_get deployed.
I've