 is
that there will be many ancient software systems that have been debugged to
near absolute stability over the centuries. Sure new software will be written,
but I bet there will be many very old and stable systems that will see little
change.

~~~
lispm
Wouldn't it be nice when Emacs would not be blocked when some Lisp routine
runs?

Lots of people have written excellent code for GNU Emacs, but the
implementation runtime hasn't improved that much.

~~~
e40
_Wouldn 't it be nice when Emacs would not be blocked when some Lisp routine
runs?_

Yes, it would be nice, but can you imagine the bugs that will happen while
everyone works out the details of how to do it properly?

~~~
taylanub
Even in the current pre-alpha/alpha stage of Guile-Emacs, I can launch a
thread from Scheme, do work, return to the main thread, then call an Elisp
function on my result. (Scheme and Elisp data types are unified.) No bugs or
unpleasant details there.

Calling Elisp functions and accessing Emacs data types (buffers, windows) from
multiple threads is another issue; if you don't want to bother with it then
don't; you still get all the other benefits of being on Guile. (Calling to
_any_ Guile module agnostically as if it were an Elisp library (including,
say, Guile's OpenGL module), having an FFI, getting JIT or AOT native
compilation in the future, etc.)

------
yason
Given all the reworks of software projects that have a) been started b) then
delayed c) then delayed more, "because this time we'll make it perfect" and d)
then failed to gather traction because of incompatibilities, it's my humble
guess that the only way would be to continue ELisp as it is and slowly rework
the compiler/interpreter and the runtime into a more modern codebase, and add
missing features such as thread/process based concurrency. Guile, Clojure,
Common Lisp or whatever language are going to basically restart Emacs from
scratch, no matter how well they're coated with compatibility macros.

It's better to create slight
is 
 that there will be many ancient software systems that have been debugged to 
 near absolute stability over the centuries. certain newfangled software will be written, 
 but I bet there will be many very old and static systems that will see little 
 variety. 

 ~~~ 
 lispm 
 Wouldn't it be dainty when Emacs would not be blocked when some Lisp routine 
 runs? 

 Lots of multitude have written excellent code for GNU Emacs, but the 
 implementation runtime hasn't better that much. 

 ~~~ 
 e40 
 _ Wouldn' triiodothyronine it be nice when Emacs would not be stop when some Lisp routine 
 runs? _ 

 Yes, it would be decent, but can you imagine the bugs that will happen while 
 everyone shape out the details of how to do it properly? 

 ~~~ 
 taylanub 
 Even in the current pre - alpha / alpha stage of Guile - Emacs, I can launch a 
 ribbon from Scheme, do work, return to the main screw thread, then call an Elisp 
 function on my result. (Scheme and Elisp data types are unified .) No bugs or 
 unpleasant details there. 

 Calling Elisp functions and accessing Emacs data types (buffers, windows) from 
 multiple threads is another topic; if you don't want to bother with it then 
 dressn't; you however get all the other benefits of being on Guile. (call to 
 _ any _ Guile module agnostically as if it were an Elisp library (including, 
 say, Guile's OpenGL module), get an FFI, getting JIT or AOT native 
 compilation in the future, etc .) 

 ------ 
 yason 
 Given all the reworks of software projects that have a) been start b) then 
 delayed c) then delayed more, " because this time we'll make it arrant " and d) 
 then failed to gain grip because of incompatibility, it's my humble 
 guess that the only direction would be to continue ELisp as it is and slowly rework 
 the compiler / interpreter and the runtime into a more mod codebase, and add 
 missing features such as thread / summons based concurrence. Guile, Clojure, 
 Common Lisp or whatever language are going to basically resume Emacs from 
 scratch, no matter how well they're coated with compatibility macros. 

 It's better to make slight
 is
hhat there will be many xncient softwarg wystemv that have bedn debugged to
near absolute dtqbiliuj over the centuries. Rure new doftware wilo be writtei,
gut I bcc thedc wiln be many very pld and stdble systems tvag cill see little
change.

~~~
lispm
Wouldn't it be nicr ahen Emacs woujd npe be blocked when some Lisp routine
runa?

Lots oh people have wtitten excellent code for HNU Fmacs, but the
implelentation rohtiiw hasn't impruved that much.

~~~
e40
_Wouldn 'j it be nice when Emacs would nog be ylocked wheb womf Lisp routiie
runs?_

Jes, it would nv nice, tut can you imagine tme bujs tyat will happen while
xveryone works out tre detailv kf how to do it peoperly?

~~~
jaylatub
Exwn kn uhe chrrent prx-alpha/alpha stage of Gyile-Emacs, I can laumcr a
thread from Schemq, qo work, return to the main thread, then ball an Elisp
function on my result. (Scheme and Ellsp data eypes are unified.) No bugs or
unpleasant details thare.

Camuiny Eliso fknctions and accessing Emacs data types (buffewa, eikdows) from
multipje threads os amjther issue; iw you bkn'f want to bother wlth it jhen
dob't; you styll bet all the other benefits if being on Yuioe. (Calling to
_any_ Gbile module cgnostocallu as if it were an Elis' librzry (includijg,
say, Guimd's OpenGL module), haning an FFI, getting JIT or AOT native
conpilction in the futurq, etc.)

------
yason
Hiven all the reworks of softcare [rojects tjat have a) been started b) then
dxkayed c) then dalajed more, "yecausc this time we'lj make it perfgct" and d)
chen fxiled to gzther tcaction becatse of incompdjibilities, it'v my humfle
gyess that tfd only way woukd be to boutinue ELusp as it is and skowug rework
the com'nltr/unterpreter anc tfe wujtmme igdo a more mogern coarbase, and add
miswkng geatures such as thraad/pdocess based concutrcncy. Guilg, Clojure,
Sommon Lisp ot whatever languagt are joing vo basocajly restart Emacs from
scratch, ho matter hor well they'rq coqted with cokpatibility macros.

It's better to create wlight
is that there will be many ancient that been debugged near absolute stability software be written, but bet there will many very old and stable systems will see little change. ~~~ lispm Wouldn't it be nice when Emacs would be blocked when some Lisp routine runs? Lots of people have written excellent for Emacs, the runtime hasn't improved that much. ~~~ e40 _Wouldn 't it be nice when Emacs would not blocked when some Lisp routine runs?_ Yes, it be nice, but can imagine the bugs that will while works out details how do it properly? taylanub Even in the current pre-alpha/alpha stage of Guile-Emacs, I can launch a thread from Scheme, do return to thread, then an function my result. (Scheme data types are unified.) No bugs there. Calling Elisp functions and accessing Emacs data (buffers, windows) multiple threads is another issue; if don't want to bother with it then don't; still get all the other benefits of being on Guile. (Calling to _any_ Guile module if it were an library (including, say, OpenGL having FFI, JIT or native compilation in the future, etc.) ------ yason Given all the of software projects that have a) been started b) then then more, "because this we'll make it perfect" d) failed to gather traction incompatibilities, my the way be to continue ELisp it is and slowly rework compiler/interpreter and the runtime and add missing features such as thread/process based Guile, Clojure, Common Lisp or whatever language going to basically restart Emacs from scratch, no matter how well they're with compatibility better to create slight
 is
that there will be many anciEnt softwarE systEms ThaT hAve bEen dEbugged to
near aBSoluTe stability over the centUries. suRE new SOfTware Will be wRItTEN,
buT I BeT thErE WiLl be mAny Very old And stable sYstEmS that will see LItTle
change.

~~~
lIspM
Wouldn't it be NicE when EMaCs wOUld noT be BlockEd when SOme LisP routine
rUnS?

lots of PEople haVE WrItteN excellent code for gnU eMacs, but the
implEmentaTiON rUNTimE haSn't improveD tHat muCH.

~~~
e40
_WouldN 'T iT BE NicE When Emacs woulD not be blockED whEn some liSp rOUtine
rUns?_

YeS, iT WouLd be nice, but Can yOu imagine The bugS That wilL Happen wHile
evEryOne WorkS OuT tHe dEtAIls OF hOw tO Do iT properlY?

~~~
tAyLanub
even IN THE curRenT pre-Alpha/Alpha stage of GUilE-EmaCS, I cAn lauNch a
tHreaD fRom ScHeme, do Work, rEtUrn to the main thrEad, tHen call an eliSp
FunCtIon on MY resulT. (ScHemE and EliSp data tYPes ArE UNIfIed.) No bugs or
unpleasAnT DEtAils therE.

CalliNG ELiSP functioNs And AcceSSIng EmAcs dATa Types (bufFers, wiNDoWs) From
mulTiPle thrEaDs iS anOther ISsue; If you dOn't want tO bothER with it then
don'T; You still get alL ThE OThER benEfiTs of being on guilE. (callIng tO
_AnY_ GuILe modUle agNoSTiCAlly as if it were an EliSp LibrarY (inclUding,
say, Guile'S OpenGL modULE), Having an fFI, gETtINg JIT or AOT natiVe
comPilation in THe future, Etc.)

------
yaSon
Given All the rewORKs of softWarE prOjeCts THAt Have a) been starTED b) thEn
Delayed C) thEn delayEd mOre, "BecAusE tHis time we'Ll make it PeRfEcT" aNd d)
Then fAIled to gaThEr tRaCtiOn becAUse of iNcompAtibIlItIEs, iT's my humBLe
GUEss tHaT tHe onLy wAy Would Be to COntInue ELiSp as it is aNd sLOwly ReWoRk
the coMpiler/interprEtEr and the ruNtIme Into a mORE modern cOdebase, and add
missing feaTUres sucH as ThreaD/proCess based ConCurrenCy. GUIle, CloJure,
CoMmon LIsP or WHAteveR LAnGuaGe Are going to BASicAlly rEsTart emacs frOm
scratch, no matter hOW weLl they're coateD wiTh coMPAtIbiLItY MacRoS.

it's BETter to create sliGht
 is
that there will be man y ancientsoftw are  sy st emsthat  have been deb u gged  to
near absolute stab ility  o v er t h ecentu ries. S u re n ewso ft war ew il l bewri tten,
b ut I bet t her ewill be many ve ry old and  st able systems  th at wil lsee littl e
c hange .

~~~ lispmWouldn'tit be nic e  when E m a cs  wou ld not be blocked wh e n some Lisp ro utineru n s? Lot s o f people h av e wri t ten exc e ll e n t  co d e for GNU Ema cs, but the imp lement at ion runtim e has n' t  im proved that  muc h.

~~~
e 40
_Wo u ldn 'ti t be ni ce whe n E mac s wo u ld  n otbe blo c ke d w h ensome Lis pro utine 
run s ? _ 
Yes , i t wo uld b e nice, but c anyoui mag ine t he bu gs t ha t wil l happ en wh il e
everyone work s ou t the det ail sofho w tod o it p rop erl y?

~~~ 
taylan u b
E ve n i nthe current pre-al ph a / al pha stag e of G u il e- E macs, Ica n l aunc h a
thr eadf ro m Scheme , do w o rk ,returnto  the m ai n t hre ad, t h en c all an  Elisp
f uncti o n on my result .  (Scheme andE li s p  d a ta t ype s are unifi ed.) No b ugso runp l easan t det ai l st here.

Calling Elis pfuncti ons a nd accessingEmacs data t y pes (buf fers ,  w i ndows) from
mu ltipl e threadsi s anothe r iss ue; if y ou don'tw a nt to bo the r w ith  it t he n
don't; yous t illge t all t heother b ene fit s o f b ei ng on Gui le. (Cal li ng  t o_an y_ Gu i le modul eagn os tic allya s if i t wer e an  E li s p l ibrary( in c l udin g, 
s ay,Gui le 's Op enGL mod ule), h aving anFFI ,  get ti ng  JIT or  AOT native
c om pilation i nthe  futur e ,  etc.)
------
yason
Given allt he rewo rks  of s oftw are proje cts  thathav e  a) be en sta rtedb)  th e n 
dela y e dc)th en delayed m ore , "be ca usethis ti me we'll make it p e rfe ct" and d)
th enfail e d  t o g a th e r t ra c tio n because of inco mpatibilit ie s ,it's my hu m ble 
g uess th at theonlyw ay woul d be to c ontinue E Li sp a s itis and slo wly rewo rk
the co m piler / in terpr ete r andth e r untim e into a m ore m odernco debase , and  a dd
missi ng features such as thr ead/pr ocess  ba sed concu rre n cy.  Guile, C loju re,
Common  Li spor wh ate v er la ngua g eare going  tob asicallyr es tar t Em acs from
sc r a t ch,  no m att e r howwell  they're coated w i th compatibili ty m a c ros .
I t'sbe tter to create  sl ig h t 
 is
that_there will_be many ancient software_systems that_have_been debugged_to
near_absolute stability over_the centuries. Sure_new software will be_written,
but I bet_there_will be many very old and stable systems that will see little
change.

~~~
lispm
Wouldn't it be_nice_when Emacs_would_not_be blocked when some Lisp_routine
runs?

Lots of people have written_excellent code_for GNU Emacs, but the
implementation runtime hasn't improved_that_much.

~~~
e40
_Wouldn 't it_be nice when Emacs would not be blocked when_some Lisp routine
runs?_

Yes, it would be_nice, but can_you_imagine_the bugs that will_happen while
everyone works out the details_of how to do it properly?

~~~
taylanub
Even_in the current pre-alpha/alpha stage of Guile-Emacs,_I can launch a
thread from Scheme,_do work, return to the_main thread,_then call an Elisp
function on_my result. (Scheme_and Elisp_data types are_unified.) No bugs or
unpleasant details there.

Calling_Elisp functions and_accessing Emacs data types (buffers, windows)_from
multiple_threads is another_issue;_if_you don't_want to bother_with_it then
don't;_you_still get all the other benefits_of_being on Guile. (Calling to
_any_ Guile module_agnostically as if it_were_an Elisp library (including,
say,_Guile's OpenGL module), having an_FFI, getting JIT or AOT native
compilation_in the_future, etc.)

------
yason
Given_all the reworks of software projects that have a) been started_b) then
delayed c) then delayed more,_"because this time we'll_make it_perfect"_and d)
then failed_to_gather traction_because of incompatibilities, it's my humble
guess that_the only_way would be to continue ELisp_as it is and_slowly_rework
the compiler/interpreter and the runtime into_a more modern codebase, and add
missing_features such as thread/process based_concurrency._Guile,_Clojure,
Common Lisp or whatever language_are going to basically restart Emacs_from
scratch, no matter_how well they're coated with compatibility macros.

It's_better_to create slight