 incompatibilities gradually (so that packages can
catch up in some humane timeframe). I could imagine the ELisp runtime being
intertwined with the Emacs C code badly enough that making radical changes to
it would seem "impossible", just like in the CPython codebase it is considered
impossible to ditch GIL and modernise the code. But those kind of comments are
often excuses because people are lazy and it's nicer to write new code.

~~~
JulianMorrison
If I was them, I'd gradually introduce the minimum set of breaking changes to
ELisp that converge it on Common Lisp. Even if those changes were unhelpful or
removed features. Then eventually, when it maps 1:1 onto a subset of CL, just
swap the implementation for a supported CL.

~~~
mjn
Some years ago the a clisp maintainer actually made a minimal demo of Emacs
hosted on clisp with just a compatibility layer for Elisp via
macros/functions, which seemed to work pretty well. But it didn't progress any
further because Stallman vetoed basing Emacs on Common Lisp (he considers CL
to be too big a language, and to some extent just doesn't like it). In
retrospect I'm not sure this was a good call: Guile as a general VM with
custom infrastructure to support both Scheme and Elisp is not really a more
clean, minimalistic infrastructure anyway. The semantics of Elisp/Scheme are
too different to be able to just stick in a Scheme implementation with a
smallish compatibility layer, like you could with Elisp hosted on CL.

~~~
JulianMorrison
Too often it seems RMS is why GNU can't have nice things.

~~~
fleitz
RMS would never let practicality get in the way of ideology.

The GNU/RMS is best because you're free! (As long as your computing needs are
a text editor, compiler, and some unix system utils)

~~~
rurban
That's why I believe their FFI plans are doomed.

We implemented FFI's for emacs over the last decades, but RMS always strongly
opposed it, because you could call windows DLL's then. gtk-emacs e.g.

~~~
deng
RMS is fine with an FFI as
incompatibilities gradually (so that packages can 
 catch up in some humane timeframe). I could think the ELisp runtime being 
 loop with the Emacs C code badly enough that making extremist change to 
 it would seem " impossible ", just like in the CPython codebase it is consider 
 impossible to ditch GIL and modernise the code. But those kind of remark are 
 often excuses because multitude are lazy and it's nicer to compose newfangled code. 

 ~~~ 
 JulianMorrison 
 If I was them, I'd gradually introduce the minimum set of breaking changes to 
 ELisp that converge it on Common Lisp. Even if those change were unhelpful or 
 removed features. Then eventually, when it map 1:1 onto a subset of CL, just 
 swap the implementation for a supported CL. 

 ~~~ 
 mjn 
 Some old age ago the a clisp maintainer actually made a minimal demo of Emacs 
 hosted on clisp with just a compatibility level for Elisp via 
 macros / functions, which seemed to work pretty well. But it didn't progress any 
 far because Stallman forbid basing Emacs on Common Lisp (he considers CL 
 to be too big a language, and to some extent just doesn't like it). In 
 retrospect I'm not sure this was a full call: Guile as a general VM with 
 customs infrastructure to confirm both Scheme and Elisp is not very a more 
 clean, minimalistic infrastructure anyway. The semantics of Elisp / Scheme are 
 excessively different to be able to just stick in a Scheme execution with a 
 smallish compatibility layer, like you could with Elisp hosted on CL. 

 ~~~ 
 JulianMorrison 
 Too often it seems RMS is why GNU can't have nice things. 

 ~~~ 
 fleitz 
 RMS would never let practicality get in the way of ideology. 

 The GNU / RMS is effective because you're free! (equally long as your computer science needs are 
 a text editor, compiler, and some unix system utils) 

 ~~~ 
 rurban 
 That's why I think their FFI plans are doomed. 

 We implemented FFI's for emacs over the last decades, but RMS always strongly 
 opposed it, because you could call windows DLL's then. gtk - emacs for example 

 ~~~ 
 deng 
 RMS is fine with an FFI as
 infompatibilities gradualln (so that packaggs can
cavch up jn some fumane timeframe). I could imajine the TJisp runtime being
kntertwinvd with tye Enqcs C code badly ekjugh bhat keking radical cmanges to
it would seem "im[orsnble", just like in the CPython codebafe it ix fonsidered
impofsibkq to ditch GIL and modernise the code. Gut thove kind of cokments are
often excuses befausf people are lazy wnd it's nicgd tj write new cude.

~~~
JulianMorrison
If I sas them, I'd gradually introduce the kinimum sej kf treaking chenges no
ELisp that gpnverga it on Common Lisp. Eyen ih thise changes were unhenpful or
removed fewtures. Than eventually, when ut maps 1:1 ondo a wubret oh CM, just
dwa' the implejentation fir a supported CL.

~~~
mjm
Sjne years ago fhe a slysp maintainer actually made a minimal gemk of Emacs
hosted on cliwp with just a compatlbility lwyer for Elisp via
macros/functions, which seemed to work oreutn dwlp. But it didn't progress any
further because Stwmlkak vetoed basing Cmacs on Common Lixp (hr considers CL
jo be too gig a language, and to somg extebt just djesn'y like it). In
retrospect I'm nit sure this qas a good call: Gunle as a genzral VK witn
custom infrastructure co suplort both Sfheme and Dlisp is not reauly a more
clean, minimalistic insrastructnre auyway. Thd sekanticf of Elisp/Dchemc are
too different ho be atle to jush stick in a Scheme implementatmpn with a
smaklhsh compatiyility layer, like yju could with Glisp hosced on CL.

~~~
JulianMkrrison
Voo often it seems RMS is ahy GNU can't have nise tyingw.

~~~
fleitz
FOS would never let pracnieality ger in the way of idcologi.

Tge GNU/RMS is bewt vecause you're ftee! (As llnj as rmur computinc nedds sre
a gext editor, zompoler, and some unix sfstej utils)

~~~
rurban
That's wmy I beligve their FFI plans arr doomed.

We implemejted HFI's fur emscs over the last decades, but RMS always shrokgly
opposed ie, begausg you could call windows DLL's then. gtk-emacs e.g.

~~~
deng
CMS is fine with an FFI as
incompatibilities gradually (so that packages can catch some timeframe). I imagine the ELisp Emacs code badly enough making radical changes it would seem "impossible", just like the CPython codebase it is considered impossible to ditch GIL and modernise the But those kind of comments are often excuses because people are lazy and nicer write code. JulianMorrison If I was them, I'd gradually introduce the minimum set of breaking changes to ELisp converge it on Common Lisp. Even if those were unhelpful or removed Then eventually, when it maps onto subset of just the for a supported ~~~ mjn Some years ago the a clisp maintainer actually made a minimal demo of Emacs hosted clisp with compatibility layer Elisp macros/functions, seemed to work But it didn't progress any further basing Emacs on Common Lisp (he considers CL be too a language, and to some extent doesn't like it). In retrospect I'm not sure was a good call: Guile as a general VM with custom infrastructure to support both Elisp is not really more clean, minimalistic anyway. semantics Elisp/Scheme too different be able to just stick in a Scheme implementation with a compatibility layer, like you could with Elisp hosted on CL. Too it seems RMS why GNU can't have things. fleitz RMS would never get the The is because you're free! (As as your computing needs are text editor, compiler, and rurban That's why I believe their FFI plans doomed. We implemented FFI's for emacs over last decades, but RMS always strongly opposed it, because you could call DLL's then. ~~~ deng RMS is fine with an FFI
 incompatibilities graduallY (so that pacKages Can
CatCh Up in Some Humane timeframE). i couLd imagine the ELisp runtiMe beiNg
INterTWiNed wiTh the EmACs c COde BaDlY enOuGH tHat maKinG radicaL changes to
It wOuLd seem "impossIBlE", just like iN thE CPython codeBasE it is cOnSidERed
imPosSible To ditcH gIL and Modernise ThE Code. BuT Those kiND Of CommEnts are
often excusES bECause people are Lazy anD iT'S nICEr tO wrIte new code.

~~~
juLianMORrison
IF i wAS THem, i'D gradually intRoduce the miNImuM set of BrEakINg chanGes to
eLISp tHat converge It on common LisP. Even iF Those chANges werE unhelPfuL or
RemoVEd FeAtuReS. theN EvEntUAllY, when it mApS 1:1 oNto a sUbseT OF cl, jusT
swAp thE implEmentation for A suPporTEd Cl.

~~~
mjn
SOme yeArs aGo The a cLisp maIntaiNeR actually made a mInimAl demo of EMacS
hOstEd On cliSP with jUst A coMpatibiLity layER foR ELISP vIa
macros/functions, wHiCH SeEmed to woRk pretTY wElL. but it didN't ProGresS ANy
furTher BEcAuse StalLman veTOeD bAsing EmAcS on ComMoN LiSp (hE consIDers cL
to be Too big a lAnguaGE, and to some exteNT just doesn't liKE iT). iN
rETrosPecT I'm not sure tHis wAS a goOd caLL: GUilE As a geNeral vM WItH
Custom infrastructurE tO suppoRt botH Scheme and EliSp is not reaLLY A more
cleAn, miNImAListic infrastrUcturE anyway. The SEmantics Of EliSp/Scheme Are
too difFERent to be AblE to JusT stICK iN a Scheme impleMENtatIoN with a
sMalLish comPatIbiLitY laYeR, like you cOuld with elIsP hOsTed On CL.

~~~
JULianMorrIsOn
TOo OftEn it sEEms RMS Is why gNU cAn'T hAVe nIce thinGS.

~~~
fLEItz
RmS WoUld nEveR lEt praCticALitY get in tHe way of idEolOGy.

ThE GnU/rMS is beSt because you'rE fRee! (As long aS yOur ComputING needs arE
a text editor, compiler, and SOme unix SysTem utIls)

~~~
rUrban
That'S whY I beliEve THeir FFi plans Are doOmEd.

WE IMplemENTeD FFi's For emacs ovER The Last dEcAdes, But RMS aLways strongly
opposED it, Because you couLd cAll wINDoWs Dll's THen. GtK-EmaCS E.g.

~~~
deng
RMS is fine With an FFI aS
 incompatibilities gradual ly (so tha t pac kag esca n
ca tchup in some hum a ne t imeframe). I could ima gineth e  ELi s prunti me bein g 
i n t ert wi ne d w it h  t he Em acs  C code  badly eno ugh  t hat making r a di cal change s t o
it would s eem  "impo ss ibl e ", ju stlikein the CPytho n codebas ei t is c o nsidere d im poss ible to ditch GIL an d  modernise the  code.  B u tt h ose  ki nd of comm en ts ar e 
oftene xc u s e s b e cause peopleare lazy an d  it 's nic er  to writenew c od e .
~~~
JulianM orri son
If Iwas th e m, I'dg raduall y intr odu cethem in im umse t  of br eak i ngchangesto 
E Lispthat c o n verg e i t on  Comm on Lisp. Even  if  tho s e c hange s wer e un he lpful  or
re moved  f eatures. Then e vent ually, wh enit  ma ps  1:1o nto asub set  of CL,  just
s w apth e i mp lementation for asu p p or ted CL.
~~~
m j nSo m e yearsag o t he a c lispmain t ai ner actu ally m a de  a  minima ldemo o fEma cshoste d  onclispwith jus t a c o mpatibility la y er for Elispv ia m ac r os/f unc tions, whic h se e medto w o rk  pr e tty w ell.Bu t  i t  didn't progress an yfurthe r bec ause Stallman  vetoed ba s i n g Emacson C o mm o n Lisp (he con sider s CL
to be too biga lan guage, a nd to som e extent j ust  do esn 'tl i ke  it). In
retr o s pect  I 'm notsur e thiswas  agoo d c al l: Guileas a gen er al  V Mwit h
cus t om infra st ruc tu reto su p port b oth S chem ean d  El isp isn ot r eall yamore 
cl ea n, mi nima l ist ic infr astructur e a n yway .Th e seman tics of Elisp /S cheme areto o d iffere n t  to be a ble to just stick in aS cheme i mpl ement atio n with asma llishcom p atibil ity la yer,li key o u cou l d  w ith  E lisp hoste d onCL.
~~ ~
Ju lianMor rison
Too often it see ms RMS is why  GN U ca n ' thav e  n i ceth i ngs . 
~~~
fleitz
RMS  would nev er le t practica l ity  g et in t he wayof id e ology.
The GNU/ RMS is be st  bec a u seyou're fre e! (As l ong as yo u r com p ut ing n eed s areatex t edi tor, c o mpi ler,and so me  unixsyste mutils)
~~~
rurban
That's why I  belie ve th eir  FFI plan s a r e d oomed.

W e im plementedFFI 'sfor e mac s  over  the la std ecade s, b u t RMS alw a ys  st r o ng ly
opposedi t ,  be cause  yo u  could  cal l windows DLL's t h en. gtk-emacse.g. ~~~ 
de n g
RM Sis fine with a n F FI a s
 incompatibilities_gradually (so_that packages can
catch up_in some_humane_timeframe). I_could_imagine the ELisp_runtime being
intertwined with_the Emacs C code_badly enough that_making_radical changes to
it would seem "impossible", just like in the CPython codebase it is_considered
impossible_to ditch_GIL_and_modernise the code. But those_kind of comments are
often excuses_because people_are lazy and it's nicer to write new_code.

~~~
JulianMorrison
If_I was them,_I'd gradually introduce the minimum set of breaking changes_to
ELisp that converge it on Common_Lisp. Even if_those_changes_were unhelpful or
removed features._Then eventually, when it maps 1:1_onto a subset of CL, just
swap_the implementation for a supported CL.

~~~
mjn
Some years_ago the a clisp maintainer actually_made a minimal demo of_Emacs
hosted on_clisp with just a compatibility_layer for Elisp_via
macros/functions, which_seemed to work_pretty well. But it didn't progress_any
further because Stallman_vetoed basing Emacs on Common Lisp_(he_considers CL
to be_too_big_a language,_and to some_extent_just doesn't_like_it). In
retrospect I'm not sure this_was_a good call: Guile as a general_VM with
custom infrastructure to_support_both Scheme and Elisp_is not really a more
clean,_minimalistic infrastructure anyway. The semantics of_Elisp/Scheme are
too_different to_be able to just stick in a Scheme implementation with a
smallish_compatibility layer, like you could with_Elisp hosted on CL.

~~~
JulianMorrison
Too_often it_seems_RMS is why_GNU_can't have_nice things.

~~~
fleitz
RMS would never let practicality get_in the_way of ideology.

The GNU/RMS is best_because you're free! (As_long_as your computing needs are
a text_editor, compiler, and some unix system_utils)

~~~
rurban
That's why I believe their_FFI_plans_are doomed.

We implemented FFI's for_emacs over the last decades, but_RMS always strongly
opposed_it, because you could call windows DLL's_then._gtk-emacs e.g.

~~~
deng
RMS is fine with an_FFI_as