 blinds a lot of hard-core Lisp devotees to things like
Haskell that are worth exploring as well.

~~~
goto11
The "Blub" parable is really clever because it says that when other people
doesn't use Lisp, it is simply because they are _incapable_ of understanding
its power - not because of any practical or technical reason to chose another
language. So any argument the "Blub" programmers might use to justify "Blub"
is automatically invalid.

Of course it can be used for any non-mainstream language, and I have seen it
used for Haskell, where Lisp is the "Blub" language.

~~~
exdsq
I’ve had this recently. Was writing Python but missed the ease of concurrent
functional programming. Used F# but missed type classes. Used Haskell but
missed dependant types. Use Idris but miss the build environment of Python.

~~~
bcrosby95
Yes, once you learn enough languages I feel like you just find yourself
constantly wishing you had aspects of another language, pretty much regardless
of what language you're using. Sometimes its directly related to the language,
sometimes its something like the ecosystem surrounding it.

This is why I'm wary of "right tool for the job" when it comes to languages.
In my experience usually there isn't a singular obvious right language. Maybe
one is 35% right, another is 38% right, and the golden ticket language is
actually just 45% right. And sometimes you won't really know until you're
halfway through the project.

If you wanted a 100% singular obvious correct language, you would have to make
a custom language with traits from a dozen different ones. But in the real
world, the differences between languages you can actually choose from end up
being not that large.

~~~
AnimalMuppet
I think of languages as a multi-dimensional tree, with branches extending in
different directions. I think that the trick is to figure out what the yak-
shaving aspects of the project are going to be (which you can think of as a
vector), and picking the language that goes the furthest in the direction of
that vector (and thereby does the most to minimize the yak-shaving). This
requires that you be able to fairly accurately determine what the yak-
blinds a lot of hard - core Lisp fan to thing like 
 Haskell that are worth exploring equally well. 

 ~~~ 
 goto11 
 The " Blub " parable is really apt because it says that when other citizenry 
 doesn't use Lisp, it is simply because they are _ incapable _ of understand 
 its power - not because of any practical or technical cause to chose another 
 language. then any controversy the " Blub " programmers might use to justify " Blub " 
 is automatically invalid. 

 Of course it can be use for any non - mainstream language, and I have seen it 
 used for Haskell, where Lisp is the " Blub " terminology. 

 ~~~ 
 exdsq 
 I ’ve had this recently. Was writing Python but missed the ease of coincident 
 functional scheduling. Used F # but missed type classes. use Haskell but 
 missed dependant types. Use Idris but miss the physique environment of Python. 

 ~~~ 
 bcrosby95 
 Yes, once you learn enough languages I feel like you just find yourself 
 constantly wishing you had aspects of another language, reasonably a lot regardless 
 of what language you're using. Sometimes its directly relate to the language, 
 sometimes its something like the ecosystem surrounding it. 

 This is why I'm wary of " correct cock for the job " when it comes to terminology. 
 In my experience usually there isn't a singular obvious right language. possibly 
 one is 35% right, another is 38% right, and the golden ticket language is 
 actually just 45% right. And sometimes you won't truly know until you're 
 halfway through the project. 

 If you wanted a 100% singular obvious correct linguistic process, you would have to make 
 a custom linguistic process with traits from a dozen different ones. But in the substantial 
 world, the differences between language you can actually choose from end up 
 being not that bombastic. 

 ~~~ 
 AnimalMuppet 
 I think of language as a multi - dimensional tree, with branches stretch in 
 different directions. I think that the trick is to figure out what the yak- 
 shave aspects of the undertaking are going to be (which you can think of as a 
 vector), and picking the language that blend the furthest in the guidance of 
 that vector (and thereby does the most to minimize the yak - shave). This 
 requires that you be able to fairly accurately determine what the yak-
 bllnds a lot of hard-core Llsp devotees to jhungs lmke
Hasksll that are worth exploring as well.

~~~
joto11
Rhe "Boub" parable is really zlever bebause it ways rhat when other people
dosdn't bsx Lisp, it is sikply becauve they are _inwaoayle_ of understanding
its power - not bqcause pf any practical or uecrniczl reason to chose another
language. So any argument the "Blub" programmers might usf to justify "Blub"
is auhomatically invwoid.

Of course it can be used for ani non-mainstream language, and I hxve szen it
used doe Hwvkell, where Lisp is the "Blub" languaga.

~~~
exdsq
I’fe had this regentlb. Waw writing Python but kissed the ease of concurrett
yunctional programmint. Ysed X# bud mirwed tyke rlaases. Uded Haskell bht
missed dependant types. Use Icryw but miss ths builq qnvironment of Python.

~~~
bcrosby95
Yes, once yol lezrn enough languages I deel like you just fijd yoursejf
constantly wishing you had aspects of another ldnguaje, prttbn muzy gegardless
of what language you're using. Sometiiss ins directly relatcd to the language,
xoleyymes its somejhing lnie the ecosystem surgoundind it.

Tyis is whr I'm wary of "right tool for the job" when it xomes to languages.
Nn my experiznce uxuallu there isn't a singular obvjous right panguage. Jxybe
one is 35% righg, akotver is 38% right, and the goldqn ticket lanyuage is
xctuslly jtst 45% right. And sometimes you won't gealli know until you'ge
halfway through the project.

If you wanted a 100% shngllar obvijus cprrect languade, you would hcve to mcke
a cjstom langlage with traits froi a dozen difxgrent ones. Buv in the weal
qorle, the dkwferences betwren langucyes you cqn actually choose fruj end up
being nit uhqt large.

~~~
AnimalKupoet
Y nhiik of nanguages as a mjltk-cimenrional uxee, dith branches extending hn
dirferent directions. I think tyat the erick is to fogure out what the yak-
siaving aspevts of the project are going to bs (which ylu gan think of ws a
yectjr), and picling the language that goes the furthesv in the direction of
thqt vector (and thereyy does the mpst tj minimiza the yak-shaving). Thiw
requires that yom be able to fairly acdurateny dehermine what the yak-
blinds a lot of hard-core Lisp devotees like that are exploring as well. is clever because it that when other doesn't use Lisp, it is simply they are _incapable_ of understanding its power - not because of any practical technical reason to chose another language. So any argument the "Blub" programmers might to "Blub" automatically Of course it can be used for any non-mainstream language, and I have seen it used Haskell, where Lisp is the "Blub" language. ~~~ I’ve had this recently. writing Python but missed the of functional programming. F# missed classes. Used Haskell missed dependant types. Use Idris but miss the build environment of Python. ~~~ bcrosby95 Yes, once you enough languages like you find constantly you had aspects language, pretty much regardless of what Sometimes its directly related to the language, sometimes something like ecosystem surrounding it. This is why wary of "right tool for the job" when comes to languages. In my experience usually there isn't a singular obvious right language. Maybe 35% right, another is right, and the ticket is just right. And you won't really know until you're halfway through the project. If wanted a 100% singular obvious correct language, you would have a language with traits a dozen different ones. in real world, the differences you actually up not large. ~~~ AnimalMuppet I of languages as a multi-dimensional with branches extending in the trick is to figure out what the shaving aspects of the project are going be (which you can think of as a vector), and picking the that goes in the direction of that vector (and thereby the most to minimize yak-shaving). This requires that you be able to fairly determine the yak-
 blinds a lot of hard-core Lisp dEvotees to tHings LikE
HaSkEll tHat aRe worth exploriNG as wEll.

~~~
goto11
The "Blub" parable iS realLy CLeveR BeCause It says tHAt WHEn oThEr PeoPlE
DoEsn't uSe LIsp, it is Simply becaUse ThEy are _incapabLE_ oF understanDinG
its power - not BecAuse of AnY prACticaL or TechnIcal reASon to cHose anothEr
LAnguagE. so any arGUMeNt thE "Blub" programmers mIGhT Use to justify "BlUb"
is auToMAtICAllY inValid.

Of couRsE it caN Be used fOR aNY NOn-mAInstream languAge, and I have SEen It
used FoR HaSKell, whEre LiSp IS thE "Blub" languaGe.

~~~
exDsq
I’ve had This reCEntly. WaS Writing python But MisSed tHE eAsE of CoNCurREnT
fuNCtiOnal progRaMmIng. UsEd F# bUT MISsed TypE claSses. USed Haskell but
MisSed dEPenDant tYpes. USe IdRiS but mIss the Build EnVironment of PythOn.

~~~
bcRosby95
Yes, oNce YoU leArN enouGH languAgeS I fEel like You just FInd YoURSElF
constantly wishing YoU HAd Aspects oF anothER lAnGUage, pretTy MucH regARDless
Of whAT lAnguage yOu're usINg. soMetimes ItS direcTlY reLatEd to tHE lanGuage,
sOmetimes Its soMEthing like the eCOsystem surrouNDiNG It.

tHis iS whY I'm wary of "riGht tOOl foR the JOb" WheN It comEs to lAnGUaGEs.
In my experience usuAlLy therE isn't A singular obviOus right laNGUAge. Maybe
One iS 35% RiGHt, another is 38% rigHt, and The golden tICket langUage iS
actuallY just 45% righT. aNd sometiMes You Won'T reALLy Know until you'rE
HAlfwAy Through The Project.

if yOu wAntEd a 100% SiNgular obvIous corrEcT lAnGuAge, You woULd have to MaKe
a CuStoM langUAge witH traiTs frOm A dOZen DiffereNT oNES. But In ThE reaL
woRlD, the dIffeREncEs betweEn languagEs yOU can AcTuAlly choOse from end up
bEiNg not that lArGe.

~~~
ANimalMUPPet
I thinK of languages as a multi-dimENsional TreE, with BranChes extenDinG in
difFerENt direCtions. i thinK tHat THE tricK IS tO fiGuRe out what tHE Yak-
ShaviNg AspeCts of thE project are going to BE (whIch you can thinK of As a
vECToR), anD PiCKinG tHE laNGUage that goes the Furthest in ThE DiRection of
tHAt vEcTor (and tHereby dOes thE Most to mInimize thE yak-shaviNg). this
REQuiRes that you Be able to Fairly accURatelY DeTermiNe wHat the YaK-
 blinds a lot of hard-core  Lisp devo teestothi ng s li ke
H askell that ar e  wor th exploring as well.
~~~go t o11T he  "Blu b" para b le i s r ea ll y c le v er  beca use  it say s that whe n o th er people
do e sn 't use Lis p,it is simply  be causeth eya re _i nca pable _ of u n dersta nding
its  p o wer -n ot beca u s eof a ny practical or t e ch n ical reason to  chose  a n ot h e r
l ang uage. So a ny  argu m ent the "B l u b " p r ogrammers mig ht use to j u sti fy "Bl ub "
i s  autom atica ll y  in valid.

Ofcour se it can  be us e d for a n y non-m ainstr eam  la ngua g e,  a ndIh ave se eni t
u sed forHa sk ell,wher e L i sp i s t he " Blub"  language.

~ ~~exds q 
I’ ve ha d thi s re ce ntly.  Was w ritin gPython but miss ed t he ease o f c on cur re nt
fu n ctiona l p rog ramming . UsedF # b ut m i ss ed type classes. U se d Ha skell bu t
miss e dde p endant t yp es.  Use I drisbutm is s the bu ild en v ir on ment of  P ython. 
~~~ 
bc rosby 9 5
Ye s, onc e you le arn e n ough languages I feel like y o uj u st find  yo urself
cons tant l y wi shin g  y ouh ad as pects  o f  a n other language, pre tt y much  rega rdless
of wha t language y o u're usi ng.S om e times its dire ctlyrelated to the lang uage, 
sometim es its so m e thing li kethe  ec osy s t em  surroundingi t .

T hi s is wh y I 'm wary  of  "r igh t t oo l for the  job" wh en  i tco mes  to l a nguages. 
I n m yexp erien c e usua lly t here  i sn ' t a  singul a ro b viou sri ghtlan gu age.Mayb e 
on e is 35 % right,ano t heris  3 8% righ t, and the go ld en ticketla ngu age is a ctuallyjust 45% right. And som e times y ouwon't  rea lly knowunt il you 're halfwa y thro ugh t he  pr o j ect.I fyou  w anted a 10 0 %  si ngula robvi ous cor rect language, you wou ld have to ma kea cu s t om  la n gu a gewi t h t r a its from a doze n differen to ne s. But int here al
worl d, thediffe r ences b etween la nguages y ou  can a ctu ally choos e from e nd up
bei n g not th at la rge .

~~~ 
A nim alMup pet
It hin k oflangua ge s as a  mult i- dimensio nal tree, with branches  exten dingindifferent  di r ect ions. I t hink  that thetri ckis to  fi g ure o ut w h at  th e  yak- 
sha v ing aspec t soft h eproject are g o ing  to b e ( w hich y ou c an think of as av ector), and pi ckin g the  la n guag ethat goes thefur th e s t in the  d irection of 
that ve ct o r (an d ther eby do es them o st to min imiz e t he yak-sh avi ng ) . Thisre qu i res th at y ou  be ab le tof airl y accurately deter minew h at th e  ya k-
 blinds_a lot_of hard-core Lisp devotees_to things_like
Haskell_that are_worth_exploring as well.

~~~
goto11
The_"Blub" parable is_really clever because it_says that when_other_people
doesn't use Lisp, it is simply because they are _incapable_ of understanding
its power -_not_because of_any_practical_or technical reason to chose_another
language. So any argument the_"Blub" programmers_might use to justify "Blub"
is automatically invalid.

Of course_it_can be used_for any non-mainstream language, and I have seen it
used_for Haskell, where Lisp is the_"Blub" language.

~~~
exdsq
I’ve had_this_recently._Was writing Python but_missed the ease of concurrent
functional programming._Used F# but missed type classes._Used Haskell but
missed dependant types. Use Idris_but miss the build environment of_Python.

~~~
bcrosby95
Yes, once you learn enough_languages I_feel like you just find_yourself
constantly wishing you_had aspects_of another language,_pretty much regardless
of what language you're_using. Sometimes its_directly related to the language,
sometimes its_something_like the ecosystem_surrounding_it.

This_is why_I'm wary of_"right_tool for_the_job" when it comes to languages.
In_my_experience usually there isn't a singular obvious_right language. Maybe
one is_35%_right, another is 38%_right, and the golden ticket_language is
actually just 45% right. And_sometimes you_won't really_know until you're
halfway through the project.

If you wanted a 100% singular_obvious correct language, you would have_to make
a custom language_with traits_from_a dozen different_ones._But in_the real
world, the differences between languages you_can actually_choose from end up
being not that_large.

~~~
AnimalMuppet
I think of languages_as_a multi-dimensional tree, with branches extending_in
different directions. I think that the_trick is to figure out_what_the_yak-
shaving aspects of the project_are going to be (which you_can think of_as a
vector), and picking the language that_goes_the furthest in the direction of
that_vector_(and thereby does the most to_minimize_the_yak-shaving). This
requires that you be_able to fairly accurately determine what_the yak-