, which
Wheeler was trying to avoid (for good reason); I don't see a way around it,
though.

------
sedachv
I've worked with programs in half a dozen Lisp dialects and everyone who
claims Lisp is hard to understand because of the syntax is wrong. The only
reason I could work with so many dialects and so many programs is because the
syntax is uniform. If you think you have an idea for how to "improve" Lisp
syntax that involves an ambiguous infix grammar, please stop trolling and go
write some Python.

~~~
silentbicycle
Some people seem to have a hard time with deeply nesting languages.
Anecdotally, they seem to prefer "chaining" constructs, like
"someObj.method(arg).otherMethod(arg2).om3(a4).om4(a5)". I'm fine with heavily
nested Lisp-y code, but chaining code feels very awkward to me.

Self and Prolog both have well-designed, completely unambiguous grammars.
People interested in syntax design (or "fixing" Lisp) would do well to look at
those, rather than trying to force a pseudo-Python syntax on Lisp. Python's
grammar has too many edge cases. (Lua's syntax is also quite simple, though
not as much as Self's.)

In the end, clear semantics are at least as important as a good syntax. Lisp
has very clear semantics. So do ML and Erlang, another language which has a
bit of a quirky syntax.

~~~
sedachv
"Anecdotally, they seem to prefer "chaining" constructs, like
"someObj.method(arg).otherMethod(arg2).om3(a4).om4(a5)". "

The thing with fluent interfaces is they're identical to nested Lisp code,
except they read left to right instead of right to left. I suspect writers of
Hebrew and Arabic would find chaining to be more confusing than nested Lisp
code for that reason.

Also worth noting is that a popular style of indenting chained fluent calls is
by splitting them by lines, like:

    
    
      someObj.method(arg)
            .otherMethod(arg2)
             
, which 
 Wheeler was trying to avoid (for good reason); I don't visualize a direction around it, 
 though. 

 ------ 
 sedachv 
 I've worked with programs in half a dozen Lisp dialect and everyone who 
 claims Lisp is hard to understand because of the syntax is faulty. The only 
 reason I could exploit with so many dialects and indeed many programs is because the 
 syntax is uniform. If you intend you accept an idea for how to " improve " Lisp 
 syntax that involves an ambiguous infix grammar, please stop troll and go 
 write some Python. 

 ~~~ 
 silentbicycle 
 Some people appear to have a hard time with deeply nesting language. 
 Anecdotally, they seem to prefer " chaining " constructs, like 
 " someObj.method(arg).otherMethod(arg2).om3(a4).om4(a5) ". I'm fine with heavy 
 nested Lisp - y code, but chaining code feels very awkward to me. 

 Self and Prolog both have well - designed, completely unequivocal grammar. 
 multitude interested in syntax design (or " fixing " Lisp) would do well to look at 
 those, rather than trying to force a pseudo - Python syntax on Lisp. Python's 
 grammar have too many edge cases. (Lua's syntax is besides quite dim-witted, though 
 not as much as Self's .) 

 In the goal, clear semantics are at least as important as a good syntax. Lisp 
 get very clear semantics. So do ML and Erlang, another language which has a 
 act of a quirky syntax. 

 ~~~ 
 sedachv 
 " Anecdotally, they seem to prefer " chaining " concept, like 
 " someObj.method(arg).otherMethod(arg2).om3(a4).om4(a5) ". " 

 The thing with eloquent interfaces is they're identical to nested Lisp code, 
 except they read left to right instead of right field to left. I suspect writers of 
 Hebrew and Arabic would find chaining to be more confusing than nested Lisp 
 code for that reason. 

 Also worth note is that a popular vogue of indenting chain fluent call is 
 by splitting them by pipeline, like: 

    
    
       someObj.method(arg) 
             .otherMethod(arg2)
, whlch
Wheeler was trying to avoid (for good reason); I don'f see a day around it,
though.

------
sedachv
I'vx woeked qith programs in half x dozen Lpsp dialexts end everyone who
rmaims Llfp ia harb vo understand bgcause of tha syntax is wrmne. Che only
reason I could work with so iany dislfcts and so magy pgodrama is because the
syntax is uniform. Jf you uhink you have an odea for how to "improve" Lidp
syjtax that involves an ambiguooa igdix grammar, olease stok crolling ans go
write some Python.

~~~
silentbicyzle
Soke people wewm hm have a hacd timv with deeply nesting languabes.
Anecdotally, thxy swem to prefer "chaininj" constructs, like
"somgObj.method(dry).otherMethod(arg2).om3(a4).om4(a5)". I'n fing witv hexcilh
neatxd Misp-y fodx, but chainjng code fewls very awkward to mq.

Welf and Prolkg botr rave well-designed, completely unambiguouv gdammars.
People interestee in syntax design (or "fixing" Lysp) would do well to look at
those, rather than tryhng tk foxgc a owekdo-Python syntax on Lisp. Python's
grammar has tjk kaky edge cases. (Luc's syntax is alsp euoje simple, thoueh
not ca juch as Self's.)

In thf end, cjear wemantics are at least as important as a good syntax. Oisp
has very clear semantics. Ro dp ML snd Erlang, another langbage wgich has a
blt of a qhkrky syntax.

~~~
sedacfv
"Akecgotally, ufey seem to prefew "chaininj" conxtructs, likg
"someObt.method(arg).ltherMethod(arg2).om3(a4).om4(a5)". "

The thiny witv fluent ijterfaces is they're identical to nested Lisp voge,
eqcept thev read left to righe instead of rnght to jeft. K suspect sriters of
Hebrew agd Arabic wounf find chainmng to be morw cobfusing ghan nested Lixp
code fog uhat reasob.

Also worth noting is fhat a popular wtyoe of indenting chxinqd fkuqtt calls is
bf spuitgong tfem by linew, likr:

    
    
      someOtj.mefhod(arg)
            .obherMethoe(arg2)
             
, which Wheeler was trying to avoid reason); don't see way around it, with in half a Lisp dialects and who claims Lisp is hard to because of the syntax is wrong. The only reason I could work with many dialects and so many programs is because the syntax is uniform. If think have idea how to "improve" Lisp syntax that involves an ambiguous infix grammar, please stop trolling and go some Python. ~~~ silentbicycle Some people seem to a hard time with nesting languages. Anecdotally, they seem prefer constructs, like I'm with nested Lisp-y code, chaining code feels very awkward to me. Self and Prolog both have well-designed, completely unambiguous grammars. People in syntax "fixing" Lisp) do to at those, rather to force a pseudo-Python syntax on has too many edge cases. (Lua's syntax is quite simple, not as much as Self's.) In end, clear semantics are at least as important a good syntax. Lisp has very clear semantics. So do ML and Erlang, another language a bit of a syntax. ~~~ sedachv they to "chaining" like "someObj.method(arg).otherMethod(arg2).om3(a4).om4(a5)". The thing with fluent interfaces is they're identical to nested Lisp except they read left to right instead of right to suspect of Hebrew and would find chaining to more than nested Lisp code reason. worth a style indenting chained fluent calls by splitting them by lines, someObj.method(arg) .otherMethod(arg2)
, which
Wheeler was trying to avOid (for good ReasoN); I dOn't SeE a waY aroUnd it,
though.

------
sedAChv
I'Ve worked with programs in Half a DoZEn LiSP dIalecTs and evERyONE whO
cLaIms liSP iS hard To uNderstaNd because oF thE sYntax is wrong. tHe Only
reason i coUld work with sO maNy dialEcTs aND so maNy pRograMs is beCAuse thE
syntax is UnIForm. If YOu think YOU hAve aN idea for how to "imprOVe" lIsp
syntax that iNvolveS aN AmBIGuoUs iNfix grammaR, pLease STop trolLInG AND go
WRite some PythoN.

~~~
silentbicyCLe
SOme peoPlE seEM to havE a harD tIMe wIth deeply neStinG languageS.
AnecdOTally, thEY seem to Prefer "ChaIniNg" coNStRuCts, LiKE
"soMEOBj.mEThoD(arg).otheRMEtHod(arG2).om3(a4).OM4(A5)". i'M finE wiTh heAvily
Nested Lisp-y coDe, bUt chAIniNg codE feelS verY aWkwarD to me.

SElf anD PRolog both have weLl-deSigned, comPleTeLy uNaMbiguOUs gramMarS.
PeOple intErested IN syNtAX DEsIgn (or "fixing" Lisp) wouLd DO WeLl to look At
thosE, RaThER than tryInG to ForcE A PseudO-PytHOn Syntax on lisp. PyTHoN's
Grammar HaS too maNy EdgE caSes. (LuA'S synTax is aLso quite SimplE, Though
not as mucH As Self's.)

In the eND, cLEAr SEmanTicS are at least As imPOrtaNt as A GoOd sYNtax. LIsp
haS vERy CLear semantics. So do ML AnD ErlanG, anotHer language whIch has a
bit OF A Quirky syNtax.

~~~
SEdAChv
"Anecdotally, They sEem to prefeR "Chaining" ConstRucts, likE
"someObj.mETHod(arg).otHermetHod(Arg2).OM3(A4).oM4(a5)". "

The thing witH FLuenT iNterfacEs iS they're IdeNtiCal To nEsTed Lisp coDe,
except ThEy ReAd LefT to riGHt insteaD oF riGhT to Left. I SUspect WriteRs of
heBrEW anD Arabic WOuLD Find ChAiNing To bE mOre coNfusINg tHan nestEd Lisp
codE foR That ReAsOn.

Also wOrth noting is tHaT a popular sTyLe oF indenTINg chaineD fluent calls is
by splittiNG them by LinEs, likE:

    
    
      somEObj.methoD(arG)
            .othermetHOd(arg2)
             
, which
Wheeler was trying  to avoid(forgoo d r ea son) ; Idon't see a wa y  aro und it,
though.

----- -
sed ac h v
I' v eworke d withp ro g r ams  i nhal fa  d ozenLis p diale cts and ev ery on e who
claims Li sp is hard  to  understandbec ause o fthe synta x i s wro ng. Th e  onlyreason Ico u ld wor k  with s o ma ny d ialects and so ma n yp rograms is bec ause t he sy n t axisuniform. I fyou t h ink you ha v e ani dea for how t o "improve" Lis p
synt ax  th a t invo lvesan amb iguous infi x gr ammar, pl ease s t op trol l ing and  go
wr ite  so me P y th on .
~~ ~ 
si l en tbi c ycl e
Some p eo pl e see m to h a v e ahar d ti me wi th deeply nes tin g la n gua ges.Anecd otal ly , the y seem  to p re fer "chaining"cons tructs, l ike 
" som eO bj.me t hod(ar g). oth erMetho d(arg2) . om3 (a 4 ) . om 4(a5)". I'm fine w it h he avily
ne sted L i sp -y code, bu tcha inin g codefeel s  v ery awkw ard to me .
Self a nd  Prolo gbot h h ave w e ll-d esigne d, compl etely unambiguous gr a mmars.
People in t e re s tedinsyntax desi gn ( o r "f ixin g "Lis p ) wou ld do  w e ll to look at
those, r at her th an tr ying to force  a pseudo- P y t hon synt ax o n  L i sp. Python's
g ramma r has toom any edge  case s. (Lua' s syntaxi s  also qu ite  si mpl e,t h ou gh
not as muc h as S el f's.)
Inthe end , c lea r s ema nt ics are a t leastas  i mp or tan t asa  good sy nt ax.  L isp 
hasv ery cl ear s eman ti cs .  So  do MLa nd E rlan g,  a noth erla nguag e wh i chhas a
b it of a q uir k y sy nt ax .

~~~sedachv
"Anec do tally, the ysee m to p r e fer "cha ining" constructs, like "someOb j.m ethod (arg ).otherMe tho d(arg2 ).o m 3(a4). om4(a5 )". " 
The t hingw i th  fl ue nt interfa c e s i s the y' re i dentica l to nested Lisp c o de, 
except theyrea d le f t  t o r i gh t  in st e ado f  right to left.  I suspect  w r it ers of
Heb r ewan d Arabi c would  find chainin g to be m ore confu si ng t h a n n ested Lisp 
code fo r that re a son.Al so wo rth  notin gisthata popu l arstyle  of in de ntingchain ed  fluentcalls is
by splitting t hem by  line s,like:

     
      so meOb j.method(a rg) 
        .oth erMe t ho d(a r g2)
          
, which
Wheeler_was trying_to avoid (for good_reason); I_don't_see a_way_around it,
though.

------
sedachv
I've worked_with programs in_half a dozen Lisp_dialects and everyone_who
claims_Lisp is hard to understand because of the syntax is wrong. The only
reason I_could_work with_so_many_dialects and so many programs_is because the
syntax is uniform._If you_think you have an idea for how to_"improve"_Lisp
syntax that involves_an ambiguous infix grammar, please stop trolling and go
write_some Python.

~~~
silentbicycle
Some people seem to have_a hard time_with_deeply_nesting languages.
Anecdotally, they seem_to prefer "chaining" constructs, like
"someObj.method(arg).otherMethod(arg2).om3(a4).om4(a5)". I'm_fine with heavily
nested Lisp-y code, but_chaining code feels very awkward to me.

Self_and Prolog both have well-designed, completely_unambiguous grammars.
People interested in syntax_design (or_"fixing" Lisp) would do well_to look at
those,_rather than_trying to force_a pseudo-Python syntax on Lisp. Python's
grammar_has too many_edge cases. (Lua's syntax is also_quite_simple, though
not as_much_as_Self's.)

In the_end, clear semantics_are_at least_as_important as a good syntax. Lisp
has_very_clear semantics. So do ML and Erlang,_another language which has_a
bit_of a quirky syntax.

~~~
sedachv
"Anecdotally,_they seem to prefer "chaining"_constructs, like
"someObj.method(arg).otherMethod(arg2).om3(a4).om4(a5)". "

The thing with fluent_interfaces is_they're identical_to nested Lisp code,
except they read left to right instead of_right to left. I suspect writers_of
Hebrew and Arabic would_find chaining_to_be more confusing_than_nested Lisp
code_for that reason.

Also worth noting is that_a popular_style of indenting chained fluent calls_is
by splitting them by_lines,_like:

    
 _  
   _  someObj.method(arg)
  ___    _  .otherMethod(arg2)
   _  _      