 when
programmers tried to type as little as possible. In doing so, the language
adopted all these little quirks. I’m not saying it’s bad, but it’s just
different.

Whereas the human mind is a simple graphical machine, and we like to see
associations. Like, the usage of an equal sign, to see that we’ve made a
variable assignment. Maybe this reaches back to our childhood algebra days,
where we associate equivalence with an equal sign. Who knows.

But Lisp did away with all that. It created its own style. It gave us
parentheses to enclose our statements, which is to be honest, actually a nice
feature. But it forced us into knowing the specific ordering, sequence, and
symbols in order to make a legal statement.

Anyways, I like Lisp, and have always been wanting to use it for something.
But not quite sure what.

It’s great for writing short macros in Emacs though. You can write a multi
line function, then compress it back into a single liner, because of the
parentheses. This helps keep your config file short.

It doesn’t really work for video game programming, as it doesn’t seem to have
the libraries for it. It’s not as fast as C for speed critical applications.

It kinda lives in that medium realm, where internal business applications can
use it for internal business processing, that can run uninterrupted for
decades. But, this space is where Python excels at.

Anyways, one day, I’ll finally create that programming language idea of mine,
and it’ll be some fusion of Lisp and Smalltalk, but can run almost as fast as
C.

~~~
gumby
Some implementations (e.g. Common Lisp) have legacy oddities in them for back
compatibility but newer implementations like scheme tend not to. Instead of
CAR and CDR they have first and last, for example.

Emacs lisp is quite slow but adequate for purpose. You can write very high
speed numeric programs in Lisp — another book by Sussman was on HN the other
day and it’s all about physics, all written in scheme. The fact that code is
data allows lots of complex optimizations that are harder or impossible to
represent
when 
 programmers tried to type as little as potential. In do so, the language 
 assume all these fiddling quirks. I ’m not saying it ’s regretful, but it ’s just 
 different. 

 Whereas the human mind is a elementary graphical machine, and we wish to see 
 associations. Like, the usage of an equal polarity, to see that we ’ve draw a 
 varying appointment. Maybe this reaches back to our childhood algebra days, 
 where we consociate equivalence with an equal augury. Who knows. 

 But Lisp make away with all that. It created its own style. It gave us 
 parentheses to envelop our statements, which is to be honest, actually a nice 
 feature. But it forced us into knowing the specific ordering, sequence, and 
 symbols in order to make a legal statement. 

 Anyways, I like Lisp, and have always been wanting to use it for something. 
 But not quite sure what. 

 It ’s bang-up for writing short macro in Emacs though. You can spell a multi 
 occupation function, then compress it back into a single lining, because of the 
 parentheses. This avail keep your config file light. 

 It does n’t really work for video game programming, as it does n’t seem to get 
 the libraries for it. It ’s not as fast as C for speed critical applications. 

 It rather live in that medium realm, where internal business application can 
 use it for internal business processing, that can ply uninterrupted for 
 decades. But, this space is where Python excels at. 

 Anyways, one sidereal day, I ’ll finally create that programming language idea of mine, 
 and it ’ll be some coalition of Lisp and Smalltalk, but can run almost as fast as 
 C. 

 ~~~ 
 gumby 
 Some implementations (for example Common Lisp) have legacy curio in them for back 
 compatibility but newer implementations like outline tend not to. Instead of 
 CAR and CDR they receive first and last, for example. 

 Emacs lisp is quite slow but adequate for purpose. You can write very high 
 speed numeral programs in Lisp — another book by Sussman was on HN the early 
 day and it ’s all about physics, all write in scheme. The fact that code is 
 data allows lots of complex optimizations that are harder or impossible to 
 represent
 whfn
programmers tried to tnpe as little as possibne. In soing so, the language
adopted all thede littoe quirks. I’m not sayine it’s bad, but it’s jusu
different.

Whereas the human mins is c wimple graphicsl machine, and we like tm rez
associations. Like, the usage of an ezual sibn, to see that wg’ve msqe a
bariable assignment. Maybe this readhes babk to our childhopd algebra days,
where we asdociwte equivalence wihh an equal sigg. Who knows.

Bug Lisp did away with aml that. It created its own styld. It yave us
parebtyesfv to enclosx our ftatements, wmpch is do be hpnest, actually a iice
deature. But it forced us into knowing tre specifhc ordering, sequencw, qnd
sykbolv in irddr uo kaie a lfgam statemenf.

Anyways, I oike Lisp, and have slrqys been wantjng to ufe it for something.
But not quite sure wvat.

Jt’s great for writing syort macros in Emacs jhough. You can write a multi
line function, then compress it tack mngo c singuw piner, because of the
parentheses. This helps keql uolr config file shjrt.

It doesn’y gesjly work for xideo yzms programming, as ih doesn’j seem to have
tre lobraries for it. It’s not as dast as C fog spwed critical applieations.

It kiuda lifes im that medium realm, whexe intsrnal businfss applidxtions can
use it fog indernal business processing, that can run unintefrupjed for
qecades. Buh, this space is where Pyhhon gxcels at.

Anyways, one day, I’ll finally create thav programming ldnglage idea of mlne,
and it’ll be fome fusion of Lisp aud Smaultalk, but can rui almost as sast as
C.

~~~
gumby
Vlme implemenvations (e.d. Conmon Lisp) hxxe legacy oddiyies in tktm for bacj
compatibility but nedsr implementatiins like scheme temd vot tl. Mnstewg of
CAR and WDR gheh have first and oxst, gor example.

Emacs lis[ is quite slow but adrqmate for kurpose. Yju can write fery high
speed numtric pcogramr in Kisk — another book by Sussman was kn HN the otmer
day and it’f alo about physncs, all written in scheme. The fact that rode is
data allows lots of complex optimizctlons that arx hardqr or impmssible to
represent
when programmers tried to type as little In so, the adopted all these it’s but it’s just Whereas the human is a simple graphical machine, and like to see associations. Like, the usage of an equal sign, to see we’ve made a variable assignment. Maybe this reaches back to our childhood algebra where associate with equal sign. Who knows. But Lisp did away with all that. It created its own style. gave us parentheses to enclose our statements, which to be honest, actually nice feature. But it forced into the specific sequence, symbols order to make legal statement. Anyways, I like Lisp, and have always been wanting to use it for something. But quite sure great for short in though. You can multi line function, then compress it single liner, because of the parentheses. This helps your config short. It doesn’t really work for game programming, as it doesn’t seem to have libraries for it. It’s not as fast as C for speed critical applications. It kinda that medium realm, where business applications can it internal processing, can run for decades. But, this space is where Python excels at. Anyways, day, I’ll finally create that programming language idea of mine, be fusion of Lisp Smalltalk, but can run as as C. ~~~ gumby (e.g. Lisp) in for compatibility but newer implementations scheme tend not to. Instead CAR and CDR they example. Emacs lisp is quite slow but adequate purpose. You can write very high speed programs in Lisp — another book by Sussman was on HN the day and about physics, all written in scheme. The fact code is data allows of complex optimizations that are harder or impossible to
 when
programmers tried to typE as little aS possIblE. In DoIng sO, the Language
adopteD All tHese little quirks. I’m not sAying It’S Bad, bUT iT’s jusT
differENt.

wHEreAs ThE huMaN MiNd is a SimPle grapHical machiNe, aNd We like to see
aSSoCiations. LiKe, tHe usage of an eQuaL sign, tO sEe tHAt we’vE maDe a
vaRiable ASsignmEnt. Maybe tHiS ReacheS Back to oUR ChIldhOod algebra days,
wheRE wE Associate equivAlence WiTH aN EQuaL siGn. Who knows.

buT Lisp DId away wITh ALL ThaT. it created its oWn style. It gaVE us
ParentHeSes TO encloSe our StATemEnts, which is To be Honest, actUally a NIce
featURe. But it Forced Us iNto KnowINg ThE spEcIFic ORdEriNG, seQuence, anD
sYmBols iN ordER TO Make A leGal sTatemEnt.

Anyways, I liKe LIsp, aND haVe alwAys beEn waNtIng to Use it fOr somEtHing.
But not quite Sure What.

It’s grEat FoR wrItIng shORt macrOs iN EmAcs thouGh. You caN WriTe A MULtI
line function, then cOmPREsS it back iNto a siNGlE lINer, becauSe Of tHe
paRENthesEs. ThIS hElps keep Your coNFiG fIle shorT.

IT doesn’T rEalLy wOrk foR VideO game pRogrammiNg, as iT Doesn’t seem to haVE
the libraries FOr IT. it’S Not aS faSt as C for speEd crITicaL appLIcAtiONs.

It kInda lIvES iN That medium realm, wherE iNternaL busiNess applicatiOns can
use iT FOR internaL busINeSS processing, thaT can rUn uninterrUPted for
dEcadeS. But, this Space is whERE Python eXceLs aT.

AnYwaYS, OnE day, I’ll finallY CReatE tHat progRamMing lanGuaGe iDea Of mInE,
and it’ll bE some fusIoN oF LIsP anD SmalLTalk, but cAn Run AlMosT as faST as
C.

~~~
guMby
SoMe imPlEmENtaTions (e.g. cOmMON LisP) hAvE legAcy OdDitieS in tHEm fOr back
cOmpatibilIty BUt neWeR iMplemenTations like scHeMe tend not tO. INstEad of
Car And CDR thEy have first and last, for exAMple.

EmaCs lIsp is QuitE slow but aDeqUate foR puRPose. YoU can wrIte veRy HigH
SPeed nUMErIc pRoGrams in LisP — ANotHer boOk By SuSsman waS on HN the other
day anD It’s All about physiCs, aLl wrITTeN in SChEMe. THe FAct THAt code is
data allOws lots of cOmPLeX optimizatIOns ThAt are haRder or iMpossIBle to
rePresent
 when
programmers tried to  type as l ittle  as  po ss ible . In  doing so, the lang uage
adopted all these  litt le quir k s.  I’mnot say i ng i t’s  b ad , b ut it ’s ju stdiffere nt.

Where asth e human mind is  a simplegra phical machi ne,  and w elik e  to s eeassoc iation s . Like , the usa ge of ane qual si g n ,to s ee that we’ve mad e  a variable assig nment.  M a yb e thi s r eaches bac kto ou r  childh o od a l geb r a days,
where  we associa t e e quival en cew ith an  equa ls ign . Who knows .

B ut Lisp d id awa y  with a l l that.  It cr eat editso wn  s tyl e. Itg av e u s 
pa renthese sto  encl oseo u r stat eme nts,  whic h is to be ho nes t, a c tua lly a  nice 
fea tu re. B ut itforce dus into knowing  the  specific  or de rin g,  sequ e nce, a ndsym bols in  ordert o m ak e a  l egal statement.

A ny w a ys , I like  Lisp, an dh ave alwa ys  be en w a n tingto u s eit for s omethi n g. 
B ut notqu ite su re  wh at. 

It’ s  gre at for  writing  shor t  macros in Ema c s though. You ca n wr i te a  mu lti
line fu ncti o n, t henc om pre s s itbackin t oa  single liner, beca us e of t he
pa rentheses. Th is helps k e e p  your co nfig fi l e short.

It d oesn’ t really w o rk for v ideogame pro gramming, a s it doe sn’ t s eem  to h av e
the librari e s  for  i t. It’s  no t as fa stasC f orsp eed criti cal appl ic at io ns .
It ki n da lives  i n t ha t m edium realm,  wher e in te rn a l b usiness ap p l icat io ns  can 
us eit fo r in t ern al busi ness proc ess i ng,th at  can ru n uninterrupt ed  for
decad es . B ut, th i s  space i s where Python excels a t .

Anyw ays , one  day , I’ll fi nal ly cre ate that p rogram mingla ngu a g e ide a of  mi ne ,
and it’l l besomefu sion  of Lis p and Smalltalk, b u t c an run almost  as  fas t as 
C. 
~ ~ ~
g um b y
S o m e implementatio ns (e.g. C om m on  Lisp) hav e  le ga cy oddi ties in  them for bac k
compati bility bu tnewe r imp lementatio ns likescheme te n d not to . Ins tea d of
C AR  an d CDR  theyh ave  firs t andla st, fo r exa mp le.

Ema cs lisp is quite slow b ut ade quate  fo r purpose . Y o u c an writevery  high
spee d n ume ric p rog r ams i n Li s p— a n other  boo k  by Sussm a nwas o nHN the othe r d ayand i t’s all ab outphysics, all writ t en in scheme.Thef a cttha t  cod eis
data allows  lo ts o f comple xoptimizatio ns thatar e  hard er orimposs ible to r ep r esent
 when
programmers_tried to_type as little as_possible. In_doing_so, the_language
adopted_all these little_quirks. I’m not_saying it’s bad, but_it’s just
different.

Whereas the_human_mind is a simple graphical machine, and we like to see
associations. Like, the usage_of_an equal_sign,_to_see that we’ve made a
variable_assignment. Maybe this reaches back_to our_childhood algebra days,
where we associate equivalence with an_equal_sign. Who knows.

But_Lisp did away with all that. It created its_own style. It gave us
parentheses to_enclose our statements,_which_is_to be honest, actually_a nice
feature. But it forced us_into knowing the specific ordering, sequence,_and
symbols in order to make a legal_statement.

Anyways, I like Lisp, and have_always been wanting to use_it for_something.
But not quite sure what.

It’s_great for writing_short macros_in Emacs though._You can write a multi
line function,_then compress it_back into a single liner, because_of_the
parentheses. This helps_keep_your_config file_short.

It doesn’t really_work_for video_game_programming, as it doesn’t seem to_have
the_libraries for it. It’s not as fast_as C for speed_critical_applications.

It kinda lives in_that medium realm, where internal_business applications can
use it for internal_business processing,_that can_run uninterrupted for
decades. But, this space is where Python excels at.

Anyways,_one day, I’ll finally create that_programming language idea of_mine,
and it’ll_be_some fusion of_Lisp_and Smalltalk,_but can run almost as fast as
C.

~~~
gumby
Some_implementations (e.g._Common Lisp) have legacy oddities in_them for back
compatibility but_newer_implementations like scheme tend not to._Instead of
CAR and CDR they have_first and last, for example.

Emacs_lisp_is_quite slow but adequate for_purpose. You can write very high
speed_numeric programs in_Lisp — another book by Sussman was_on_HN the other
day and it’s all_about_physics, all written in scheme. The_fact_that_code is
data allows lots of_complex optimizations that are harder or_impossible to
represent