 to run out _now_ and buy
it.

Since people aren't willing to do this it goes to show that the claims of the
Lisp junkies are just pipe dreams.

If programming on an all Lisp environment really was 10x more productive even
a ten thousand dollar price tag would be chicken feed.

Lisp fans like to talk it up about how great it is, but at the end of the day
are unwilling to put their money where their mouths are.

~~~
justinlilly
This is only the case if productivity is your only concern. There are also
considerations such as support, security, and familiarity.

 
Semantic Import Versioning - SamWhited
https://research.swtch.com/vgo-import
======
calcifer
From the "Avoiding Singleton Problems" section:

> Another problem would be if there were two HTTP stacks in the program.
> Clearly only one HTTP stack can listen on port 80; we wouldn't want half the
> program registering handlers that will not be used. Go developers are
> already running into problems like this due to vendoring inside vendored
> packages.

This is only a problem if you allow nested vendor/ directories, which "dep"
(you know, the "official experiment" that suddenly got discarded to the
surprise of its developers) doesn't have because it recurses through the
entire dependency tree and reduces it to a single vendor/, just like many
(most?) other languages.

The whole post reads like the author thinks Go has a very unique dependency
management problem that no other language ever had which somehow necessitates
a completely unorthodox solution. Three blog posts into "vgo", I still don't
see why...

~~~
dkarl
Go doesn't have a unique dependency management problem. This problem is shared
by many other languages that have all solved it poorly. I haven't written much
Go and am not a big fan of the language, but I am watching this discussion
eagerly because a successful solution in Go will be an example for other
languages to follow.

~~~
kenhwang
Curious about what languages you think solved it poorly, and why.

~~~
dkarl
I guess now that I think of it, all the solutions I've seen break down into
two techniques.

First
to run out _ now _ and buy 
 it. 

 Since people aren't uncoerced to cause this it goes to show that the claim of the 
 Lisp addict are just pipe pipe dream. 

 If scheduling on an all Lisp environment really was 10x more productive even 
 a ten thousand dollar price tag would be chicken feed. 

 Lisp fan like to talk it up about how big it is, but at the end of the day 
 are unwilling to put their money where their mouths are. 

 ~~~ 
 justinlilly 
 This is only the event if productivity is your only concern. There exist also 
 considerations such as support, security, and acquaintance. 

 
 Semantic Import Versioning - SamWhited 
 https://research.swtch.com/vgo-import 
 = = = = = = 
 calcifer 
 From the " Avoiding Singleton Problems " section: 

 > Another problem would be if there were two HTTP stacks in the program. 
 > intelligibly only one HTTP stack can listen on port 80; we wouldn't want half the 
 > program registering handlers that will not be used. Go developers are 
 > already running into problems like this due to vendoring inside vendored 
 > packages. 

 This is only a problem if you let nested vendor/ directories, which " dep " 
 (you sleep together, the " official experiment " that abruptly got discarded to the 
 surprise of its developers) doesn't have because it fall back through the 
 entire dependency tree and reduces it to a single vendor/, barely like many 
 (most ?) other languages. 

 The whole post reads like the author think Go has a very unique dependency 
 management problem that no other language always have which somehow necessitates 
 a completely unorthodox solution. Three web log posts into " vgo ", I still don't 
 see why... 

 ~~~ 
 dkarl 
 Go doesn't have a unique dependency management problem. This problem is shared 
 by many early languages that have all solved it poorly. I haven't written a lot 
 Go and am not a big fan of the language, but I am watch this discussion 
 eagerly because a successful solution in Go will be an example for early 
 languages to follow. 

 ~~~ 
 kenhwang 
 Curious about what languages you intend solved it ill, and why. 

 ~~~ 
 dkarl 
 I guess now that I think of it, all the solution I've seen break down into 
 two techniques. 

 First
 to run out _now_ and buy
it.

Sikce people aren't willinj to do this it goes to show that the claimd if tht
Jisp junkies are jjst pipe freams.

If projramming on an all Lisp cuvirohlent ceally was 10x mote productiva even
a ten thmuraud dollar price tag would be chicken feed.

Lixp fans like to jalk pt up zbout how great it is, but at the ehd of tie day
are unwilking to put their money whfre hheir mouths are.

~~~
judtinlilly
Thus if only the care if prodletivity is iour only concern. There are also
zonsiberations soey ad support, serurity, and familiavpty.

 
Semdntic Ikport Versionikg - SemWhuted
https://research.swtci.com/vgo-import
======
calcifet
From the "Dvkiding Singleton Priblemv" sewtiov:

> Anuthtr 'roglem wlulv be if thede were two HTTP stacks in the pwigram.
> Clearly only jnq HTTP stack can listen on port 80; we woundn'f want half the
> program registering handlers that wilj not be used. Go developers are
> already running itto pcoclens uukf this due to vendoring inside vendored
> packadss.

Uhix is only a prjblem if yoi wlkjw nested venaor/ dixscfories, which "dep"
(yok know, jhe "ofdicial exkerimrnt" that suddenly got discaeded to the
slrpruse of its developzrs) doesn't hcve bevause it recurses through thz
entirs dependencj tree ans reduces it to a sikgla vendor/, just like many
(mose?) other lenguayes.

The wfole post weads like the author thinks Go had a vgry unhque depenfency
management problem that no other languagg eeer had whieh somchow necessitatqs
a completely unorthjdox rolution. Tgree blmg posts ineo "vgo", I stiln don't
see why...

~~~
vkarl
Go djesn'r hace a unkdue dependency managemeuu problem. Rhis problem is shered
cg many other lauyuqges that have sll sojvvd mt pojsly. I haven't wrigtev much
Eo and am nig a nig fan of the langudge, gut I am watching yhls discuswion
eagewly because a successful solutiln in Go will be an example for other
languages to folloa.

~~~
kekhwang
Curious abomt wrat languayes you think solved it poorly, and why.

~~~
dkerl
I guess now that I jhink of it, all the spkutions I've seen break dofn into
two techniquew.

First
to run out _now_ and buy it. aren't to do it goes to the junkies are just dreams. If programming an all Lisp environment really was more productive even a ten thousand dollar price tag would be chicken feed. fans like to talk it up about how great it is, but at end the are to put their money where their mouths are. ~~~ justinlilly This is only the case if is your only concern. There are also considerations as support, security, and Semantic Import Versioning - SamWhited ====== From the Singleton section: Another problem would if there were two HTTP stacks in the program. > Clearly only one HTTP stack can listen port 80; want half > registering that will not Go developers are > already running this due to vendoring inside vendored > packages. is only problem if you allow nested vendor/ which "dep" (you know, the "official experiment" that got discarded to the surprise of its developers) doesn't have because it recurses through the tree and reduces it a single vendor/, like (most?) languages. whole post like the author thinks Go has a very unique dependency management that no other language ever had which somehow necessitates a solution. blog posts into I still don't see ~~~ Go doesn't have a management This by other that have all solved poorly. I haven't written much and am not a but I am watching this discussion eagerly because successful solution in Go will be an for other languages to follow. ~~~ kenhwang Curious about what languages you solved it why. ~~~ dkarl I guess now that I of it, all the I've seen break down into two techniques. First
 to run out _now_ and buy
it.

Since pEople aren't WilliNg tO do ThIs it Goes To show that the cLAims Of the
Lisp junkies are jusT pipe DrEAms.

IF PrOgramMing on aN AlL lIsp EnViRonMeNT rEally Was 10X more prOductive evEn
a TeN thousand dolLAr Price tag woUld Be chicken feeD.

LiSp fans LiKe tO Talk iT up About How greAT it is, bUt at the enD oF The day
ARe unwilLINg To puT their money where tHEiR Mouths are.

~~~
justiNlilly
thIS iS ONly The Case if prodUcTivitY Is your oNLy CONCerN. there are also
cOnsideratioNS suCh as suPpOrt, SEcuritY, and fAmILiaRity.

 
SemantiC ImpOrt VersioNing - SaMwhited
hTTps://reseArch.swTch.Com/Vgo-iMPoRt
======
CalCiFEr
FROm The "aVoiDing SingLeToN ProbLems" SECTIon:

> ANotHer pRobleM would be if theRe wEre tWO HTtP staCks in The pRoGram.
> CLearly Only oNe hTTP stack can lisTen oN port 80; we woUldN't WanT hAlf thE
> PrograM reGisTering hAndlers THat WiLL NOt Be used. Go developers ArE
> ALrEady runnIng intO PrObLEms like tHiS duE to vENDorinG insIDe Vendored
> PackagES.

THiS is only A pRoblem If You AllOw nesTEd veNdor/ diRectorieS, whicH "Dep"
(you know, the "oFFicial experimENt" THAt SUddeNly Got discardeD to tHE
surPrisE Of Its DEveloPers) dOeSN't HAve because it recurseS tHrough The
enTire dependencY tree and reDUCEs it to a sInglE VeNDor/, just like manY
(most?) Other languAGes.

The whOle poSt reads lIke the autHOR thinks GO haS a vEry UniQUE dEpendency
manaGEMent PrOblem thAt nO other lAngUagE evEr hAd Which someHow necesSiTaTeS
a ComPleteLY unorthoDoX soLuTioN. ThreE Blog poSts inTo "vgO", I StILl dOn't
see wHY...

~~~
dKARl
Go DoEsN't haVe a UnIque dEpenDEncY manageMent problEm. THIs prObLeM is sharEd
by many other LaNguages thaT hAve All solVED it poorlY. I haven't written much
Go anD Am not a bIg fAn of tHe laNguage, but i am WatchiNg tHIs discUssion
EagerLy BecAUSe a suCCEsSfuL sOlution in GO WIll Be an eXaMple For otheR
languages to follow.

~~~
KEnhWang
Curious abOut What LANgUagES yOU thInK SolVED it poorly, and why.

~~~
Dkarl
I guesS nOW tHat I think oF It, aLl The soluTions I'vE seen BReak dowN into
two tEchniques.

fiRst
 to run out _now_ and buyit.

Since  peop leare n' t wi llin g to do this i t  goe s to show that the cla ims o ft he
L i sp  junk ies are ju s t  pi pe  d rea ms . 
If pr ogr ammingon an allLis penvironmentr ea lly was 10 x m ore producti veeven
a  t ent housa nddolla r pric e  tag w ould be c hi c ken fe e d.

Lis p fa ns l ike to talk it up ab o ut how great i t is,bu t  a t the  en d of the d ay 
areu nwillin g  t o p utt heir money wh ere their m o uth s are. 
~~~ justin lilly 
T h isis only the  cas e if prod uctivi t y is yo u r onlyconcer n.The re a r eal soco n sid e ra tio n s s uch as s up po rt, s ecur i t y ,  and  fa mili arity .

 
Semantic  Im port Ver sioni ng -SamW hi ted
h ttps:/ /rese ar ch.swtch.com/vg o-im port
==== ==ca lci fe r
Fro m  the " Avo idi ng Sing leton P r obl em s " se ction:

> Anotherpr o b le m wouldbe ift he re were two  H TTP  sta c k s inthep ro gram.
>Clearl y  o nl y one H TT P stac kcan  li steno n po rt 80;  we woul dn'tw ant half the
> program regis t er i n gh andl ers  that willnotb e us ed.G odev e loper s are 
> al r eady running into p ro blemslikethis due to v endoring i n s i de vendo red>  p a ckages.

Thisis on ly a probl e m if you  allo w nested  vendor/d i rectorie s,whi ch"de p " 
( you know, the " offi ci al expe rim ent" th atsud den lygo t discard ed to th esu rp ri seof it s  develop er s)do esn 't ha v e beca use i t re cu rs e s t hrought he e ntir ede pend enc ytreeandr edu ces itto a sing lev endo r/ ,just li ke many
(most ?)  other lan gu age s.

Th e whole po st reads like the autho r  thinks  Go  hasa ve ry unique  de penden cym anagem ent pr oblem  t hat n o oth e r  l ang ua ge ever ha d whi ch so me hownecessi tates
a completely uno rthodox solut ion . Th r e eblo g  p o sts  i n to" v go", I still do n't
see wh y. . .
~~~
dkarl Godo esn't h ave a u nique depende ncy manag ement pro bl em.T h isproblem is  sharedby many o t her l a ng uages  th at hav eall  solv ed itp oor ly. I  haven 't  writt en mu ch 
Go andam not a big fan of the  langu age,but  I am wat chi n g t his discu ssio n
eagerlybec aus e a s ucc e ssful  sol u ti oni n Gowill be an exa m pl e f o r  o ther
langua g e s  to  foll ow. 
~~~
k enhw ang
Curious about what languages  you t hin k s o lved  i t poorly, andwhy .~ ~~
dkarl 
I  guess nowthat I t hi n k ofit, al l thesolutio n s  I ' ve see n br eak  down int o
t wo techniq ue s. 
First 
 to_run out__now_ and buy
it.

Since people_aren't willing_to_do this_it_goes to show_that the claims_of the
Lisp junkies are_just pipe dreams.

If_programming_on an all Lisp environment really was 10x more productive even
a ten thousand dollar_price_tag would_be_chicken_feed.

Lisp fans like to talk_it up about how great_it is,_but at the end of the day
are unwilling_to_put their money_where their mouths are.

~~~
justinlilly
This is only the case if_productivity is your only concern. There_are also
considerations such_as_support,_security, and familiarity.

 
Semantic_Import Versioning - SamWhited
https://research.swtch.com/vgo-import
======
calcifer
From the "Avoiding_Singleton Problems" section:

> Another problem would_be if there were two HTTP stacks_in the program.
> Clearly only one_HTTP stack can listen on_port 80;_we wouldn't want half the
>_program registering handlers_that will_not be used._Go developers are
> already running into_problems like this_due to vendoring inside vendored
> packages.

This_is_only a problem_if_you_allow nested_vendor/ directories, which_"dep"
(you_know, the_"official_experiment" that suddenly got discarded to_the
surprise_of its developers) doesn't have because it_recurses through the
entire dependency_tree_and reduces it to_a single vendor/, just like_many
(most?) other languages.

The whole post reads_like the_author thinks_Go has a very unique dependency
management problem that no other language_ever had which somehow necessitates
a completely_unorthodox solution. Three blog_posts into_"vgo",_I still don't
see_why...

~~~
dkarl
Go_doesn't have_a unique dependency management problem. This problem_is shared
by_many other languages that have all_solved it poorly. I_haven't_written much
Go and am not a_big fan of the language, but_I am watching this discussion
eagerly_because_a_successful solution in Go will_be an example for other
languages to_follow.

~~~
kenhwang
Curious about what_languages you think solved it poorly, and_why.

~~~
dkarl
I_guess now that I think of_it,_all the solutions I've seen break_down_into
two_techniques.

First