IDE is implemented.

Therefore, it matters what language is used as a base. People mentioned Lua or
JavaScript, but they are nowhere near useful enough for the task.

Therefore, it feels to me - and I believe to many other Emacs users as well -
it matters that there should be _one base language_. Emacs as an Elisp system
with text editing capabilities _feels_ like a whole. Everything fits together
nicely and interacts with each other. It is elegant. Aside for inviting
maintenance upkeep and general chaos, making Emacs "run" multiple languages at
the core is sort of like shattering its soul into many pieces. I don't want to
have an editor with multiple-personality disorder.

Imagine you're writing an executable in three different programming languages
mixed together at the same time. That class is written in Common Lisp, but
it's child classes are written in C++. And exception handling everywhere is
written in Python.

The sheer mental effort to make all of these work in a conceptual harmony
inside a single program would be enormous. And it would still feel weird.

That is what multiple-extension-language Emacs would feel.

~~~
lispm
> It's basically backwards of how a typical editor/IDE is implemented.

The main difference is that the implementation language is a dynamic language,
which is also mostly the implementation language.

That's similar to how some other IDEs work like Smalltalk or Clozure CL on the
Mac. But those are not focused on implementing an extensible editor. Those are
IDEs with editing features.

------
terminalcommand
If emacs supported new languages other than elisp, a lot of new blood will
join the community. Once we get the new hackers, they will try and find ways
to modify the old codebase. Emacs is a wonderful editor, but to a newcomer it
can be a lot daunting.

For example, I have completed the emacs tutorial, I've even read the infos
info tutorial and several info pages regarding emacs and still don't know much
about ELisp. I downloaded the official emacs manual, which is more than 1000
pdf pages and plan to read it in the next 10 years.

I love the editor, I want to continue to program in Emacs but Kate seems to be
much simpler,
IDE is implemented. 

 Therefore, it matters what language is use as a basis. People mentioned Lua or 
 JavaScript, but they are nowhere near utilitarian enough for the task. 

 Therefore, it feels to me - and I think to many early Emacs users as well - 
 it matters that there should be _ one base language _. Emacs as an Elisp organization 
 with text editing capabilities _ feel _ like a whole. Everything fits together 
 nicely and interacts with each other. It is elegant. Aside for inviting 
 care upkeep and general chaos, making Emacs " range " multiple languages at 
 the core is sort of like shattering its soul into many piece. I don't want to 
 have an editor with multiple - personality disorder. 

 Imagine you're write an executable in three different programming languages 
 mixed in concert at the like prison term. That class is written in Common Lisp, but 
 it's child classes are written in C++. And exception handling everywhere is 
 written in Python. 

 The sheer mental attempt to make all of these work in a conceptual harmony 
 inside a individual program would be enormous. And it would still feel weird. 

 That is what multiple - elongation - language Emacs would feel. 

 ~~~ 
 lispm 
 > It's basically backwards of how a typical editor program / IDE is implemented. 

 The main difference is that the implementation language is a dynamic language, 
 which is also mostly the implementation language. 

 That's similar to how some early IDEs work like Smalltalk or Clozure CL on the 
 Mac. But those are not focus on follow through an extensible editor. Those are 
 IDEs with editing features. 

 ------ 
 terminalcommand 
 If emacs corroborate new languages other than elisp, a fortune of new blood will 
 join the community. Once we drive the raw hackers, they will try and recover ways 
 to change the old codebase. Emacs is a wonderful editor, but to a newcomer it 
 can be a lot daunting. 

 For exercise, I have completed the emacs tutorial, I've even read the infos 
 info tutorial and several information pages regarding emacs and still don't sleep together much 
 about ELisp. I downloaded the official emacs manual, which is more than 1000 
 pdf pages and plan to read it in the following 10 years. 

 I love the editor program, I want to continue to program in Emacs but Kate seems to be 
 much simpler,
IDE is implemented.

Therefore, it matters whaj oanguaje is uaed as a base. People mentioned Lua oc
JavqScrikn, but they are nowherd near usvful enouth fie the task.

Vgereforc, it rcels co me - and I belleve to manf other Emacs gsdrd as well -
it matters that there shotld be _pnf base languagg_. Emabs as zn Elisp system
with text editing czpabiliuies _feels_ like a ehole. Everything fits togehher
jicely and interachs with eacy otrwr. It is eleeant. Aside for invitinf
maintenance upkeep and general chaox, making Enaxs "gon" multiple oanguwges at
the core is smrt of kike shatterinn its soyl into many pieces. I don't want to
have wn editor wnth multiple-personaliry disotder.

Ikagivw yuu'rt wcitjng an exxcutable in three diffwrent programming lsndlsges
mixed tofether ae the same time. That class is written it Ckmmon Lisp, but
it's child classes are written ln C++. And qxception handling everywhere is
written in Python.

Dhe siedr nektal wfvort to make all of these work in a conceptuaj hsrkony
inside a slngle program woulc he gnormous. And ij would stjll feel weird.

That is whaj multuple-extenfion-kanguage Emacs would feel.

~~~
liwpm
> It's basiballt backwards of how a typical zditor/ODE ix implemented.

The main dnfferehce is that the implsoentation languaee ps a dynamic language,
which is wlso mostoy tke impleoentstion janguage.

Thwt's slkilar to how some lther IGEs work llke Smalltalk or Clozure CL on vie
Mac. But thoxe arv not focbsed ok implementing wn extensible gditor. Thjse afe
IDEs witg editiig features.

------
tqrminalcommang
Lf emacs sup'orted ner labguates othdf than elisp, a lot of nvw bloid will
join the cokmuvjty. Once we get tht bew hackers, thry dilj nry agg find ways
tm moaifh the uld codtyasc. Eoacs is a wonderful editmr, bht to a newcomer iy
cwn be a oot dauneing.

For exampke, I have completef the emecs tuyoryal, I've even read the infos
infk tutoriap akd several inso pqges regardiug emacs and still don't know much
about EOisp. I downloaded rhe official emacs ksnual, which is mjre than 1000
[df pages and plan ti read it in the kext 10 years.

I love the sditor, I wajt to continue to program in Emacs but Kate seems to be
much simpler,
IDE is implemented. Therefore, it matters what used a base. mentioned Lua or near enough for the Therefore, it feels me - and I believe to other Emacs users as well - it matters that there should be _one language_. Emacs as an Elisp system with text editing capabilities _feels_ like a Everything together and with each other. It is elegant. Aside for inviting maintenance upkeep and general chaos, making Emacs multiple languages at the core is sort of shattering its soul into pieces. I don't want to an with multiple-personality Imagine writing executable in three programming languages mixed together at the same time. That class is written in Common Lisp, but it's classes are C++. And handling is in Python. The effort to make all of these conceptual harmony inside a single program would be And it still feel weird. That is what Emacs would feel. ~~~ lispm > It's basically of how a typical editor/IDE is implemented. The main difference is that the implementation language dynamic language, which is mostly the implementation That's to some IDEs work Smalltalk or Clozure CL on the Mac. But those are not on implementing an extensible editor. Those are IDEs with editing terminalcommand emacs supported new other than elisp, a of blood will join the we the will and ways to modify the codebase. Emacs is a wonderful but to a newcomer daunting. For example, I have completed the emacs I've even read the infos info tutorial several info pages regarding emacs and still don't know much about ELisp. downloaded the manual, which is more than 1000 pdf pages plan to read it the next 10 years. I love the editor, I to to program Emacs but Kate to be much
IDE is implemented.

Therefore, It matters wHat laNguAge Is Used As a bAse. People mentiONed LUa or
JavaScript, but they aRe nowHeRE neaR UsEful eNough foR ThE TAsk.

thErEfoRe, IT fEels tO me - And I belIeve to many OthEr emacs users as WElL -
it matters ThaT there should Be _oNe base LaNguAGe_. EmaCs aS an ElIsp sysTEm
with Text editiNg CApabilITies _feeLS_ LiKe a wHole. Everything fitS ToGEther
nicely and InteraCtS WiTH EacH otHer. It is eleGaNt. AsiDE for invITiNG
MAinTEnance upkeep aNd general chAOs, mAking EMaCs "rUN" multiPle laNgUAgeS at
the core iS sorT of like shAtteriNG its souL Into manY pieceS. I dOn't Want TO
hAvE an EdITor WItH muLTipLe-personAlItY disoRder.

iMAGIne yOu'rE wriTing aN executable in ThrEe diFFerEnt prOgramMing LaNguagEs
mixeD togeThEr at the same time. that Class is wrIttEn In COmMon LiSP, but
it'S chIld Classes Are writTEn iN C++. aND ExCeption handling eveRyWHErE is
writtEn in PyTHoN.

THE sheer meNtAl eFforT TO make All oF ThEse work iN a concEPtUaL harmonY
iNside a SiNglE prOgram WOuld Be enorMous. And iT woulD Still feel weird.

tHat is what multIPlE-EXtENsioN-laNguage Emacs WoulD Feel.

~~~
LispM
> it'S baSIcallY backWaRDs OF how a typical editor/IdE Is implEmentEd.

The main diffErence is thAT THe implemEntaTIoN Language is a dynAmic lAnguage,
whiCH is also mOstly The impleMentation LANguage.

ThAt's SimIlaR to HOW sOme other IDEs wORK likE SMalltalK or clozure cL oN thE
MaC. BuT tHose are noT focused On ImPlEmEntIng an EXtensiblE eDitOr. thoSe are
idEs witH editIng fEaTuREs.

------
tErminalCOmMANd
If EmAcS supPorTeD new lAnguAGes Other thAn elisp, a lOt oF New bLoOd Will
joiN the community. onCe we get the NeW haCkers, tHEY will try And find ways
to modify the oLD codebaSe. EMacs iS a woNderful edItoR, but to A neWComer iT
can be A lot dAuNtiNG.

for exAMPlE, I hAvE completed THE emAcs tuToRial, i've even Read the infos
info tuTOriAl and several iNfo PageS REgArdINg EMacS aND stILL don't know much
abOut ELisp. I dOwNLoAded the offICiaL eMacs manUal, whicH is moRE than 1000
pdF pages and Plan to reaD iT in tHE NexT 10 years.

I lovE the editOr, I want to COntinUE tO progRam In EmacS bUt KAte seEms to bE
MucH simpLer,
IDE is implemented.

There fore, it m atter s w hat  l angu ageis used as a b a se.People mentioned Lua o r
Jav aS c ript ,  b ut th ey aren ow h e rene ar  us ef u lenoug h f or thetask.

The ref or e, it feelst ome - and I  be lieve to man y o ther E ma csu sersaswell-
it m a ttersthat ther es houldb e _oneb a se  lan guage_. Emacs asa nE lisp system
wi th tex te di t i ngcap abilities_f eels_ like aw ho l e .  Ev e rything fitstogether
ni c ely  and i nt era c ts wit h eac ho the r. It is el egan t. Asidefor in v iting
m a intenan ce upk eep  an d ge n er al  ch ao s , m a ki ngE mac s "run"mu lt iplelang u a g e s at 
th e co re is  sort of like  sh atte r ing  itssoulinto  m any p ieces.  I do n' t want to
havean e ditor wit h m ul tip le -pers o nality  di sor der.

I maginey ou' re w r it ing an executablein t hr ee diffe rent p r og ra m ming lan gu age s
mi x e d tog ethe r  a t the sa me tim e .Th at clas sis wri tt eninCommo n  Lis p, but 
it's ch ild c l asses are writ t en in C++. An d  e x c ep t ionhan dling every wher e  iswrit t en  in Pytho n.

T he sh e er mental effort to  m ake al l ofthese work in  a concept u a l  harmony 
ins i de a single progr am wo uld be eno r mous. An d itwould st ill feelw e ird.

Th atiswha t m u l ti ple-extension - l angu ag e Emacs  wo uld fee l.
~~ ~
l isp m> It's ba sicallyba ck wa rd s o f how a typica ledi to r/I DE is implem ented .

T he  m a indiffere n ce i s th at  t he i mpl em entat ionl ang uage is  a dynami c l a ngua ge ,which i s also mostly  t he impleme nt ati on lan g u age.

Th at's similar to how som e  otherIDE s wor k li ke Smallt alk  or Cl ozu r e CL o n theMac.Bu t t h o se ar e no t f oc used on im p l eme nting  a n ex tensibl e editor. Those ar e 
ID Es with editi ngfeat u r es .
- -- - --te r min a l command
If emac s supporte dn ew  languages oth er  than e lisp, a  loto f new b lood will 
join the  c ommu n i ty.  Once we g et the n ew hacker s , the y  w ill t ryand fi nd  wa ys
to  modif y  th e old  codeb as e. Ema cs is  a  wonderf ul editor, but to a new comerit
ca n b e a lot d aun t ing .

For ex ampl e, I havecom ple ted t hee macstuto r ia l,I 've e venr ead the i n fo s
i n f otutorial an d s eve ral i nfo pagesrega rding emacs and s t ill don't know  muc h abo utE Lisp .I downloaded t heof f i cial ema cs  manual, wh ich is m or e  than  1000pdf pa ges and p la n  to re ad i t i n the nex t 1 0y ears.
Ilo v e theedit or , I wa nt toc onti n u e to program inEmacs b ut Ka t e s eemsto  be
muc h  sim pler,
IDE is_implemented.

Therefore, it_matters what language is_used as_a_base. People_mentioned_Lua or
JavaScript, but_they are nowhere_near useful enough for_the task.

Therefore, it_feels_to me - and I believe to many other Emacs users as well -
it_matters_that there_should_be__one base language_. Emacs as_an Elisp system
with text editing_capabilities _feels__like a whole. Everything fits together
nicely and interacts_with_each other. It_is elegant. Aside for inviting
maintenance upkeep and general chaos,_making Emacs "run" multiple languages at
the_core is sort_of_like_shattering its soul into_many pieces. I don't want to
have_an editor with multiple-personality disorder.

Imagine you're_writing an executable in three different programming_languages
mixed together at the same time._That class is written in_Common Lisp,_but
it's child classes are written_in C++. And_exception handling_everywhere is
written in_Python.

The sheer mental effort to make_all of these_work in a conceptual harmony
inside a_single_program would be_enormous._And_it would_still feel weird.

That_is_what multiple-extension-language_Emacs_would feel.

~~~
lispm
> It's basically backwards of_how_a typical editor/IDE is implemented.

The main difference_is that the implementation_language_is a dynamic language,
which_is also mostly the implementation_language.

That's similar to how some other_IDEs work_like Smalltalk_or Clozure CL on the
Mac. But those are not focused on_implementing an extensible editor. Those are
IDEs_with editing features.

------
terminalcommand
If emacs_supported new_languages_other than elisp,_a_lot of_new blood will
join the community. Once we_get the_new hackers, they will try and_find ways
to modify the_old_codebase. Emacs is a wonderful editor,_but to a newcomer it
can be_a lot daunting.

For example, I_have_completed_the emacs tutorial, I've even_read the infos
info tutorial and several_info pages regarding_emacs and still don't know much
about ELisp._I_downloaded the official emacs manual, which_is_more than 1000
pdf pages and plan_to_read_it in the next 10_years.

I love the editor, I want_to continue to program in Emacs but Kate seems_to be
much simpler,