, loading different versions of the library under the same name to
provide to different parts of your code. This has different risks depending on
how and when symbols are looked up or linked. In some languages you can end up
with the two versions accidentally calling into each other or using each
other's symbols. In other languages you run into the "expected Foo but got
Foo" type errors mentioned by munificent. That's what happens when you use
classloader tricks as a half-assed way of isolating "components" in Java.

Second, loading different versions of the library under different names. This
requires hacking the compiled code or the source code; convenience and
reliability will depend on the quality of the tools you're working with.
Sophistication ranges from using sed to munge source code to using tools like
objcopy that can read and rewrite compiled artifacts. Java "shading" (not
"shadowing" as I said earlier) relies on rewriting class files.

------
JeremyBanks
This article actually made the issue finally click for me: Go is having
trouble solving this problem because it has more going on in the global
environment, like its ancestor languages, and unlike more modern languages.
They need to come up with a complicated framework to reign in their spooky
action at a distance, because they have lots of implicit global relationships
where we might prefer more explicit and local ones.

Yikes.

~~~
ithkuil
> where we might prefer more explicit and local ones.

could you expand on this? who is "we" and what are those explicit and local
relationships? are you talking about an opensource ecosystem or a private
enterprise?

~~~
JeremyBanks
In this case I mean open-source communities and the companies that heavily
rely on them.

~~~
ithkuil
I'm not sure I understand your point. It seems you're implying (please correct
me if I'm wrong) that ecosystems of modern open-source languages are more
local, more tightly coupled and having people working in concert towards a
common goal.

In my experience this is often what happens when a new community is spawned.
E.g. when nodejs started it was there was always one single implementation of
that thing I needed and it was reasonably up to date with the rest of the
things around
, loading different versions of the library under the same name to 
 leave to unlike parts of your code. This has unlike risks count on 
 how and when symbols are looked up or associate. In some languages you can end up 
 with the two versions by chance calling into each other or use each 
 other's symbols. In early languages you run into the " expected Foo but got 
 Foo " type errors mentioned by munificent. That's what happen when you use 
 classloader tricks as a half - assed way of isolate " components " in Java. 

 Second, loading different versions of the library under unlike names. This 
 want hacking the compiled code or the source code; public toilet and 
 reliability will depend on the quality of the tools you're working with. 
 Sophistication ranges from using sed to munge source code to using tools like 
 objcopy that can read and rewrite compiled artifacts. Java " shading " (not 
 " shadowing " as I said earlier) trust on rewrite class file. 

 ------ 
 JeremyBanks 
 This article actually construct the issue finally click for me: Go is having 
 trouble solving this problem because it has more go on in the global 
 environment, like its ancestor languages, and unlike more modern languages. 
 They need to come up with a complicated model to reign in their spooky 
 action at a distance, because they have lots of implicit global relationships 
 where we might choose more denotative and local one. 

 Yikes. 

 ~~~ 
 ithkuil 
 > where we might prefer more explicit and local ones. 

 could you elaborate on this? who is " we " and what are those explicit and local 
 relationships? are you talking about an opensource ecosystem or a individual 
 enterprise? 

 ~~~ 
 JeremyBanks 
 In this case I mean open - source community and the companies that heavy 
 rely on them. 

 ~~~ 
 ithkuil 
 I'm not sure I understand your point. It seems you're imply (please correct 
 me if I'm faulty) that ecosystems of advanced open - source languages are more 
 local, more tightly coupled and having multitude working in concert towards a 
 common goal. 

 In my experience this is often what happens when a new community is spawned. 
 E.g. when nodejs started it was there be always one single execution of 
 that thing I needed and it was reasonably up to date with the rest of the 
 things around
, lowding different versions of the library under vhe sams name tu
provide to different parts lf your code. This has differevt risks fependint on
iow and when symukls are lookes up mc linked. In somg languages fou can end up
figh the two versions accidentally callyng intp fach other or osing qach
knhtr's symbols. In other languages yoh run iito the "expectec Foo but got
Foo" type errogs mfntioned by munififent. That's qhat yappens when you use
classloader trjcks as a half-assed way of isolxting "componentw" un Udva.

Second, liadind different yvrsions of the library under dihferwnt names. This
requirev hacking the compyled code ox the source code; concebiencg and
selixvilkty wmll depenf oi the qualify of the tiols you're working eiey.
Sophisticatikn randef from using sed to munge source code tm uaing tools like
objcopy rhat can read and rewtite compijed artifacts. Java "shading" (not
"shadowing" as I said earlmef) rtllcs ov rfwriting class files.

------
JeremyBanks
This article asfuslky made the isfue finally cpivh for me: Go ir haviuf
tdouble solving thid problgm becquse it hws mpre going on in the global
ebvironment, lpke uts ancestor langucges, and unlnke mote modrrn languages.
They need co coms up with a complicafdd framework to feinn hn their spooky
action at a distance, beccuse theh hafe lotf of implifit global relationships
ahere wa might prffer more explicit and local onxx.

Yikes.

~~~
ithkuik
> fhege we migkt prener more explicyt and local oues.

could you dxpand on nhis? who ms "we" and whwt are those adplicit and nocal
relwtiobships? are huu talking aboit an opeufourxe ecosystem or a irivaje
snterprise?

~~~
JeremvYabks
In this case I oeag lpxn-souwwe communitias avd gne coopanies thab hdaviky
rely on them.

~~~
ithkuin
I'm hot sure I understsnq your piint. It feems you're ikplying (please corgect
mx if I'o wromg) jhat ecosystems of modern open-skurce lanhuanes are more
ljcal, more tightlv coupled and having people working in cincert towards a
conmon goal.

In my expetiekce this is pften what hap[ens when a new commynity is spawned.
E.n. when nodejs started jt was therf was always one single implementation of
that thing I needed and it was rwasonaulr up to dats wiyh thv rzst of thq
thiigr around
, loading different versions of the library same to provide different parts of risks on how and symbols are looked or linked. In some languages you end up with the two versions accidentally calling into each other or using other's symbols. In other languages you run into the "expected Foo but got type mentioned munificent. what happens when you use classloader tricks as a half-assed way of isolating "components" in Java. loading different versions of the library under different This requires hacking the code or the source code; and will depend the of tools you're working Sophistication ranges from using sed to munge source code to using tools like objcopy that can read rewrite compiled "shading" (not as said relies on rewriting ------ JeremyBanks This article actually made click for me: Go is having trouble solving problem because has more going on in the environment, like its ancestor languages, and unlike more languages. They need to come up with a complicated framework to reign in their spooky a distance, because they lots of implicit relationships we prefer explicit and ones. Yikes. ~~~ ithkuil > where we might prefer more explicit local ones. could you expand on this? who is "we" are explicit and local are you talking about opensource or a private enterprise? In case communities the that heavily rely on ~~~ ithkuil I'm not sure understand your point. It me if I'm wrong) that ecosystems of modern languages are more local, more tightly coupled having people working in concert towards a common goal. In my experience is often when a new community is spawned. E.g. when started it was there always one single implementation of that thing I needed it reasonably up date with the of the things
, loading different versions oF the librarY undeR thE saMe Name To
prOvide to differeNT parTs of your code. This has difFerenT rISks dEPeNding On
how anD WhEN SymBoLs Are LoOKeD up or LinKed. In soMe languageS yoU cAn end up
with tHE tWo versions AccIdentally calLinG into eAcH otHEr or uSinG each
Other's SYmbols. in other laNgUAges yoU Run into THE "eXpecTed Foo but got
Foo" tyPE eRRors mentioned bY munifIcENt. tHAt's WhaT happens whEn You usE
ClassloADeR TRIckS As a half-assed wAy of isolatiNG "coMponenTs" In JAVa.

SecoNd, loaDiNG diFferent versIons Of the librAry undER differENt names. this
reQuiRes HackINg ThE coMpILed COdE or THe sOurce codE; cOnVenieNce aND
RELiabIliTy wiLl depEnd on the qualiTy oF the TOolS you'rE workIng wItH.
SophIsticaTion rAnGes from using sed To muNge source CodE tO usInG toolS Like
obJcoPy tHat can rEad and rEWriTe COMPiLed artifacts. Java "shAdING" (nOt
"shadowIng" as I SAiD eARlier) relIeS on RewrITIng clAss fILeS.

------
JeremyBAnks
ThIS aRtIcle actUaLly madE tHe iSsuE finaLLy clIck for Me: Go is haVing
tROuble solving thIS problem becauSE iT HAs MOre gOinG on in the gloBal
eNViroNmenT, LiKe iTS anceStor lAnGUaGEs, and unlike more modeRn LanguaGes.
ThEy need to come uP with a compLICAted framEworK To REign in their spoOky
acTion at a disTAnce, becaUse thEy have loTs of impliCIT global rElaTioNshIps
WHErE we might prefeR MOre eXpLicit anD loCal ones.

yikEs.

~~~
iThkUil
> WhEre we mighT prefer mOrE eXpLiCit And loCAl ones.

coUlD yoU eXpaNd on tHIs? who iS "we" anD whaT aRe THosE explicIT aND LocaL
rElAtioNshIpS? are yOu taLKinG about aN opensourCe eCOsysTeM oR a privaTe
enterprise?

~~~
JErEmyBanks
In ThIs cAse I meAN Open-sourCe communities and the compANies thaT heAvily
Rely On them.

~~~
ithKuiL
I'm not SurE i underStand yOur poInT. It SEEms yoU'RE iMplYiNg (please coRREct
Me if I'M wRong) That ecoSystems of modern opeN-SouRce languages aRe mOre
lOCAl, MorE TiGHtlY cOUplED And having people Working in cOnCErT towards a
cOMmoN gOal.

In my ExperieNce thIS is ofteN what happEns when a nEw CommUNIty Is spawned.
E.G. when nodEjs starteD It was THeRe was AlwAys one SiNglE implEmentaTIon Of
thaT thing i nEeded aNd it wAs ReasonabLy up to date with the rest of The
thiNgs arOunD
, loading different versio ns of thelibra ryund er  the  sam e name to
prov i de t o different parts of y our c od e . Th i shas d ifferen t  r i s ksde pe ndi ng on 
howand  when s ymbols are  lo ok ed up or lin k ed . In somelan guages you c anend up 
w ith the t woversi ons ac c identa lly calli ng into e a ch othe r or  usi ng each
other's s y mb o ls. In other l anguag es yo u run  in to the "ex pe ctedF oo butg ot F o o"t ype errors me ntioned bym uni ficent .Tha t 's wha t hap pe n s w hen you use 
cla ssloadertricks as a ha l f-assed  way o f i sol atin g  " co mpo ne n ts" in  Ja v a.
Second,  l oa dingdiff e r e n t ve rsi onsof th e library und erdiff e ren t nam es. T hisre quire s hack ing t he  compiled codeor t he source  co de ; c on venie n ce and 
re lia bilitywill de p end  o n t he  quality of the to ol s yo u're wor king w i th .S ophistic at ion  ran g e s fro m us i ng  sed tomunges ou rc e codeto  using  t ool s l ike
o b jcop y that  can rea d and rewrite compil e d artifacts.J av a "s h adin g"(not
"shado wing "  asI sa i dear l ier)relie so nr ewriting class file s. 

---- --
Je remyBanks
Thi s articlea c t ually ma de t h ei ssue finally c lickfor me: Go is havin g
tro uble sol ving this p roblem b eca use  it  ha s mo re going on i n thegl obal
en vir onment,  li keits  an ce stor lang uages, a nd  u nl ik e m ore m o dern lan gu age s. 
Th ey ne e d to c ome u p wi th  a com plicate d  f r a mewo rk  t o re ign  i n the ir s p ook y
actio n at a di sta n ce,be ca use the y have lots o fimplicit g lo bal  relat i o nships
w here we might prefer mo r e expli cit  andloca l ones.
Yik es.

~ ~~i thkuil 
> whe re we  m igh t prefe r mo reex plicit and l oca l one s. 

co uld you  expand on this? w h o i s "we" and wh ataret h os e e x pl i cit  a n d l o c al
relationship s? are you  t a lk ing abouta n o pe nsource  ecosys tem o r  a priv ate
enter prise?

~ ~~ 
Jer e m yBa nks
In thi s case I  mean ope n -sour c ecommu nit ies an dthe  comp aniest hat  heav ily
re ly  on th em.
~~ ~
ithkui l
I'm not sure I unders tand y our p oin t. It see msy ou' re implyi ng ( please cor rec t
m e ifI'm wrong ) th a teco s ystem s of modern op e n- sou r c elanguages a r e mor e
loc al, more t ight ly coupled and ha v ing people wor king i n c onc e rt t ow ards a
commongoa l. In my ex pe rience this  is ofte nw hat h appens  whena new c o m mu n ity is  spa wne d.
E.g. w hen  n o dejs st ar te d  it wa s th er e wasalways ones i ngle implementat ion o f thatt hin g I n ee ded and it w as reasona bly up to d ate wi th t he re st of t he 
thing s a ro und
, loading_different versions_of the library under_the same_name_to
provide to_different_parts of your_code. This has_different risks depending on
how_and when symbols_are_looked up or linked. In some languages you can end up
with the two versions_accidentally_calling into_each_other_or using each
other's symbols. In_other languages you run into_the "expected_Foo but got
Foo" type errors mentioned by munificent._That's_what happens when_you use
classloader tricks as a half-assed way of isolating_"components" in Java.

Second, loading different versions_of the library_under_different_names. This
requires hacking the_compiled code or the source code;_convenience and
reliability will depend on the_quality of the tools you're working with.
Sophistication_ranges from using sed to munge_source code to using tools_like
objcopy that_can read and rewrite compiled_artifacts. Java "shading"_(not
"shadowing" as_I said earlier)_relies on rewriting class files.

------
JeremyBanks
This article_actually made the_issue finally click for me: Go_is_having
trouble solving this_problem_because_it has_more going on_in_the global
environment,_like_its ancestor languages, and unlike more_modern_languages.
They need to come up with a_complicated framework to reign_in_their spooky
action at a_distance, because they have lots_of implicit global relationships
where we might_prefer more_explicit and_local ones.

Yikes.

~~~
ithkuil
> where we might prefer more explicit and local ones.

could_you expand on this? who is_"we" and what are_those explicit_and_local
relationships? are you_talking_about an_opensource ecosystem or a private
enterprise?

~~~
JeremyBanks
In this case_I mean_open-source communities and the companies that_heavily
rely on them.

~~~
ithkuil
I'm not_sure_I understand your point. It seems_you're implying (please correct
me if I'm_wrong) that ecosystems of modern_open-source_languages_are more
local, more tightly coupled_and having people working in concert_towards a
common goal.

In_my experience this is often what happens_when_a new community is spawned.
E.g. when_nodejs_started it was there was always_one_single_implementation of
that thing I needed_and it was reasonably up to_date with the rest of the
things around