 To be clear, this approach creates a bit more work for authors, but that
work is justified by delivering significant benefits to users._

Users don't want all of the work pushed onto maintainers. Life needs to be
easy for maintainers too, because happy maintainers are how users get lots of
stuff to use in the first place. If you push all of the burden onto package
maintainers, you end up with a beautiful, brilliantly-lit grocery store full
of empty shelves. Shopping is a pleasure but there's nothing to buy because
producing is a chore.

Good tools distribute the effort across both kinds of users. There's obviously
some amortization involved because a package is consumed more than it's
maintained, but I'm leery of any plan that deliberately makes life harder for
a class of users, without very clear positive benefit to others. Here, it
seems like it makes it harder to ship breaking changes, without making
anything else noticeably easier in return.

 _> They can't just decide to issue v2, walk away from v1, and leave users
like Ugo to deal with the fallout. But authors who do that are hurting their
users._

Are they hurting users worse than not shipping v2 _at all_? My experience is
that users will prefer an imperfect solution over no solution when given the
choice. It may offend our purist sensibilities, but the reality is that lots
of good applications add value to the world built on top of mediocre, half-
maintained libraries. Even the most beautiful, well-designed, robust packages
often went through a period in their life where they were hacky, buggy, or
half-abandoned.

A good ecosystem enables packages to _grow_ into high quality over time,
instead of trying to gatekeep out anything that isn't up to snuff.

 _> In Go, if an old package and a new package have the same import path, the
new package must be backwards compatible with the old package._

This doesn't define _for whom_ it must be backwards compatible. Breaking
changes are not all created equal. Semver is a pessimistic measure. You bump
the major version if a change _could break at least one user, in theory._ In
practice, most "breaking" changes do not break most users.

If you remove a function that
To be clear, this approach creates a bit more workplace for writer, but that 
 work is justified by delivering meaning benefits to users. _ 

 Users don't desire all of the oeuvre pushed onto upholder. biography needs to be 
 comfortable for maintainers too, because happy maintainers are how drug user get lots of 
 stuff to use in the first topographic point. If you push all of the burden onto package 
 upholder, you end up with a beautiful, brilliantly - lit grocery shop full 
 of empty shelf. Shopping is a pleasure but there's nothing to buy because 
 producing is a chore. 

 Good creature distribute the effort across both kinds of users. There's obviously 
 some amortization involved because a package is consumed more than it's 
 maintained, but I'm leery of any plan that deliberately makes life harder for 
 a class of users, without very clear positive benefit to others. Here, it 
 look like it makes it harder to embark break changes, without making 
 anything else noticeably comfortable in return. 

  _ > They can't just decide to issue v2, walk away from v1, and forget users 
 like Ugo to deal with the fallout. But authors who act that are hurting their 
 users. _ 

 Are they hurting users bad than not ship v2 _ at all _? My experience is 
 that users will prefer an imperfect solution over no solution when given the 
 option. It may offend our purist sensibilities, but the reality is that lots 
 of good applications add value to the world built on acme of mediocre, half- 
 maintained libraries. Even the about beautiful, well - designed, robust packages 
 often run low through a period in their life sentence where they were hacky, buggy, or 
 half - abandoned. 

 A good ecosystem enables packages to _ develop _ into high quality over time, 
 instead of trying to gatekeep out anything that isn't up to snuff. 

  _ > In Go, if an old package and a new software have the same meaning path, the 
 new package must be backwards compatible with the old package. _ 

 This doesn't define _ for whom _ it must be backward compatible. Breaking 
 changes are not all created equal. Semver is a pessimistic measure. You bump 
 the major adaptation if a variety _ could break at least one user, in theory. _ In 
 practice, most " breaking " changes do not break most users. 

 If you get rid of a function that
 To be clear, this approach greates a bit mote work hor autgors, but that
work is justified by depicerint significant benefits to users._

Lsers don'r wait all of the woci pushed onto laincamners. Life needx to be
easf for maintainarr coo, because happy maintainers are hor users gft lots of
stufs to tse jn the first place. If you push all of the burden onto lackage
maintainers, you end up aith a beautiful, bgilliantly-lut gwicery store wull
of empuy shelves. Sgopping is a pleasure but there'r notking to buy bwcakve
producing is a chore.

Good tools disdribute the effort acvoss uoth kinds of users. There'v obviously
some amjrtizatiot nnvolved because a paxkqge iv cotsumde mure tian it's
malnteined, but I'j leery of qny plan that delibtraevky makes lifs hardqr for
a class of users, without very clear poaitive benefit to otherw. Here, it
seems like ij makes it harder to ship breaking changes, without making
anfthinj dlst kjgucfably easier in return.

 _> They can't just decide fo ixsue v2, walk awcy from v1, and lesvf ifers
like Ugo jo deal wifh the fallout. But authorf who do that wre nurting their
users._

Are they yurting userf worse than not shnpping v2 _at cll_? My expetience is
that users wilu prsfer an impfrfect somjtion over no souutpon fhen givtv the
choice. It mar offend iur 'urist sdnsinilitiqs, but the realldy is that lots
of hood cppliwations adf value to the world built on top of mediocre, hdlf-
kaintainzd libvaries. Even the most beautifuk, well-dzsignea, robust pzckages
mften went ehrough a perhld in their nife whewe tyey qere hazyy, buggy, or
halg-abandoneb.

C good ecisystem enables pagkager to _grow_ into hnyh quality over tome,
knseewd os trying to gdtekdep put avything thab irn't ip to snuff.

 _> In Go, ix an old package and a ncw packagg have thq same import path, the
new packahe muvt ue baclwatds compatible with the old paciage._

This foefn't define _fjr wmom_ yt must be backwards compatible. Breaking
changes ace not all created equao. Semver is a pessiklstic measurx. You fump
the mdjor version if a chqnge _could break st least one user, in fheory._ In
prwctice, most "breaking" changes do not break most users.

If you remove a functuon thet
To be clear, this approach creates a work authors, but work is justified users._ don't want all the work pushed maintainers. Life needs to be easy maintainers too, because happy maintainers are how users get lots of stuff to in the first place. If you push all of the burden onto package you up a brilliantly-lit grocery store full of empty shelves. Shopping is a pleasure but there's nothing to buy producing is a chore. Good tools distribute the across both kinds of There's obviously some amortization involved a is consumed than maintained, I'm leery of plan that deliberately makes life harder for a class of users, without very clear positive benefit to Here, it it makes harder ship changes, without making noticeably easier in return. _> They to issue v2, walk away from v1, and users like to deal with the fallout. But who do that are hurting their users._ Are hurting users worse than not shipping v2 _at all_? My experience is that users will imperfect solution over no when given the It offend purist but the is that lots of good applications add value to the world on top of mediocre, half- maintained libraries. Even the most robust often went through period in their life they hacky, buggy, or half-abandoned. ecosystem packages high over instead of trying to out anything that isn't up snuff. _> In Go, a new package have the same import path, new package must be backwards compatible with old package._ This doesn't define _for whom_ it must be backwards compatible. changes are created equal. Semver is a pessimistic measure. You the major version if change _could break at least one user, in theory._ practice, "breaking" changes not break most If you remove function that
 To be clear, this approach creaTes a bit morE work For AutHoRs, buT thaT
work is justifiED by dElivering significant beNefitS tO UserS._

usErs doN't want aLL oF THe wOrK pUshEd ONtO mainTaiNers. LifE needs to be
EasY fOr maintainerS ToO, because haPpy Maintainers aRe hOw userS gEt lOTs of
sTufF to usE in the FIrst plAce. If you pUsH All of tHE burden ONTo PackAge
maintainers, you ENd UP with a beautifuL, brillIaNTlY-LIt gRocEry store fuLl
Of empTY shelveS. shOPPIng IS a pleasure but There's nothiNG to Buy becAuSe
pROducinG is a cHoRE.

GoOd tools distRibuTe the effoRt acroSS both kiNDs of useRs. TherE's oBviOuslY
SoMe AmoRtIZatIOn InvOLveD because A pAcKage iS conSUMED morE thAn it'S
mainTained, but I'm leEry Of anY PlaN that DelibEratElY makeS life hArder FoR
a class of users, wIthoUt very cleAr pOsItiVe BenefIT to othErs. herE, it
seemS like it MAkeS iT HARdEr to ship breaking chAnGES, wIthout maKing
anYThInG Else notiCeAblY easIER in reTurn.

 _> tHeY can't jusT decidE To IsSue v2, walK aWay froM v1, And LeaVe useRS
likE Ugo to Deal with The faLLout. But authors WHo do that are huRTiNG ThEIr
usErs._

are they hurtIng uSErs wOrse THaN noT ShippIng v2 _aT aLL_? MY Experience is
that useRs Will prEfer aN imperfect solUtion over nO SOLution whEn giVEn THe
choice. It may oFfend Our purist sENsibilitIes, buT the realIty is that LOTs
of good AppLicAtiOns ADD vAlue to the worlD BUilt On Top of meDioCre, half-
MaiNtaIneD liBrAries. Even The most bEaUtIfUl, WelL-desiGNed, robusT pAckAgEs
oFten wENt throUgh a pErioD iN tHEir Life wheRE tHEY werE hAcKy, buGgy, Or
Half-aBandONed.

a good ecOsystem enAblES pacKaGeS to _grow_ Into high qualiTy Over time,
inStEad Of tryiNG To gatekeEp out anything that isn't up TO snuff.

 _> IN Go, If an oLd paCkage and a New PackagE haVE the saMe impoRt patH, tHe
nEW PackaGE MuSt bE bAckwards coMPAtiBle wiTh The oLd packaGe._

This doesn't define _FOr wHom_ it must be baCkwArds COMpAtiBLe. bReaKiNG
chANGes are not all creAted equal. SEmVEr Is a pessimiSTic MeAsure. YoU bump
thE majoR Version If a change _Could breaK aT leaST One User, in theoRy._ In
pracTice, most "bREakinG" ChAnges Do nOt breaK mOst Users.

if you rEMovE a funCtion tHaT
 To be clear, this approac h createsa bit  mo rewo rk f or a uthors, but th a t
wo rk is justified by del iveri ng sign i fi cantbenefit s  t o use rs ._ 

U se r sdon't  wa nt allof the wor k p us hed onto mai n ta iners. Lif e n eeds to be
e asy  for m ai nta i nerstoo , bec ause h a ppy ma intainers  a r e howu sers ge t lo ts o f
stuff to use in th e  first place.If you  p u sh a llofthe burden  o nto p a ckage
m a in t a i ner s , you end upwith a beau t ifu l, bri ll ian t ly-lit  groc er y  st ore full
of  emp ty shelve s. Sho p ping is a pleas ure bu t t her e'sn ot hi ngto buy be cau s e
p roducing  i sa cho re.G o o d to ols  dis tribu te the effort  ac ross bot h kin ds of  use rs . The re's o bviou sl y
some amortiza tion  involved  be ca use  a  pack a ge iscon sum ed more  than i t 'sma i n t ai ned, but I'm leery  o f an y plan t hat de l ib er a tely mak es  li fe h a r der f or
a cl ass of u sers,w it ho ut very  c lear p os iti vebenef i t to  other s. Here,  it
s e ems like it ma k es it hardert os h ip brea kin g changes,with o ut m akin g 
a nyt h ing e lse n ot i ce a bly easier in retur n. 

 _>Theycan't just de cide to is s u e  v2, wal k aw a yf rom v1, and le ave u sers
likeU go to de al wi th the f allout. B u t  authors  wh o d o t hat a re  hurting thei r user s. _

Arethe y hurti nguse rswor se  than not  shippin gv2  _ at  al l_? M y  experie nc e i stha t use r s will  pref er a nim p erf ect sol u ti o n  ove rno  sol uti on  when  giv e n t he
choi ce. It ma y o f fend  o ur  purist  sensibilitie s,  but the r ea lit y is t h a t lots
o f good applications add value t o t he wo rldbuilt ontop  of me dio c re, ha lf-
ma intai ne d l i b rarie s .  E ven  t he most be a u tif ul, w el l-de signed,  robust packages
o f ten  went through  aperi o d  i n t h ei r  li fe whe r e  they were hack y, buggy,or ha lf-abandon e d.
A  good e cosyste m ena b les pac kages to_grow_ in to  hig h qua lity overtime,
in stead oft rying to  gate kee p outan yth ing t hat is n 'tup to  snuff .
 _> I n Go,  i f an old  package and a new pack age ha ve th e s ame impor t p a th,  the
newpack age must b e b ack wards  co m patib le w i th  th e  oldpack a ge._

Thi s  d oes n ' tdefine _for w h om_  it m ust be bac kwar ds compatible. Br e aking
changesaren o t a llc reat ed  equal. Semver  is  a p essimist ic  measure. Y ou bumpth e  majo r vers ion if  a chan g e  _ c ould b reak  at  least on e u se r , in th eo ry . _ In
p ract ic e, mos t "bre a king " changes do not b reakm o st us e rs. 

Ifyo u remov e  a f unction th at
 To_be clear,_this approach creates a_bit more_work_for authors,_but_that
work is justified_by delivering significant_benefits to users._

Users don't_want all of_the_work pushed onto maintainers. Life needs to be
easy for maintainers too, because happy maintainers_are_how users_get_lots_of
stuff to use in the_first place. If you push_all of_the burden onto package
maintainers, you end up with_a_beautiful, brilliantly-lit grocery_store full
of empty shelves. Shopping is a pleasure but_there's nothing to buy because
producing is_a chore.

Good tools_distribute_the_effort across both kinds_of users. There's obviously
some amortization involved_because a package is consumed more_than it's
maintained, but I'm leery of any_plan that deliberately makes life harder_for
a class of users, without_very clear_positive benefit to others. Here,_it
seems like it_makes it_harder to ship_breaking changes, without making
anything else noticeably_easier in return.

__> They can't just decide to_issue_v2, walk away_from_v1,_and leave_users
like Ugo to_deal_with the_fallout._But authors who do that are_hurting_their
users._

Are they hurting users worse than not_shipping v2 _at all_?_My_experience is
that users will_prefer an imperfect solution over_no solution when given the
choice. It_may offend_our purist_sensibilities, but the reality is that lots
of good applications add value_to the world built on top_of mediocre, half-
maintained libraries._Even the_most_beautiful, well-designed, robust_packages
often_went through_a period in their life where they_were hacky,_buggy, or
half-abandoned.

A good ecosystem enables packages_to _grow_ into high_quality_over time,
instead of trying to gatekeep_out anything that isn't up to_snuff.

 _> In Go, if_an_old_package and a new package_have the same import path, the
new_package must be_backwards compatible with the old package._

This doesn't_define__for whom_ it must be backwards_compatible._Breaking
changes are not all created equal._Semver_is_a pessimistic measure. You bump
the_major version if a change _could_break at least one user, in theory._ In
practice, most_"breaking" changes do_not break most users.

If you_remove_a_function that