all messages for Emacs-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed
* Re: Is Elisp really that slow?
@ 2019-05-14 23:54 Ergus
  2019-05-15 11:57 ` Emanuel Berg
                   ` (3 more replies)
  0 siblings, 4 replies; 298+ messages in thread
From: Ergus @ 2019-05-14 23:54 UTC (permalink / raw)
  To: help-gnu-emacs

Hi,

Sorry I lost the most recent messages because the mail engine disables
my account very often.

>
>OK, point taken. Users, newcomers, aren't
>impressed by Emacs. The don't dig the console
>and they use the mouse. And they want
>everything integrated, all tho, which is
>amusing, integration is limited to
>a single language.
>
Not only that, see below.
>
>(Maybe MS IDEs can do all of C#, VB(A), and
>MS Access now that I think about it...?)
>
Yes they can, VS code supports many of them, butt especially the most
popular.
>
>OK, now it gets totally confused %) The
>different language major modes are the absolute
>_backbone_ of Emacs as a programmer editor,
>indispensible! Obviously we want them for every
>conceivable language to be as good as possible!
>Setting up font-lock and indentation for
>a programming language major mode (which even
>I have done BTW) isn't what I thought we
>were talking about rather much more advanced
>stuff, the refactoring stuff (how ever that
>works), integrating the debugger and build
>process, and so on, and as for
>language-specifics, qualitatively different
>stuff, not just configuring and tweaking with
>the same old interface!
><http://user.it.uu.se/~embe8573/fps/>
>
This is something even advanced compared to a real integration we need
like unify commands bindings, interfaces and functionalities names.

I go every time to the same topic here, but all the time I only receive
complains and strong answers with strong feelings from the older
users. We NEED to update the interface (unify the bindings for all the
languages, unify packages with similar functionalities, delete unused
functionalities.) It is not a should, it is a must. 

To mention just one example: It does not make sense that C-c C-c
comments the current lines in C-mode, but sends the current sexep to
terminal in other modes, or send the messages in others. So emacs
somehow behaves as a different tool/editor for 3 different modes, so the
"unified bindings/behavior" is not an advantage anymore.

Or that we provide several options (or packages) to add parents with 300
customizable variables but a very bad default behavior. The existence of
spacemacs ergoemacs and other similar customization is a user's scream
for better defaults (I am not telling to ennable all what spacemacs
does, but we have functionalities that the users will never discover if
they don't go in the ddeep parts of the manual).

Usually the old users (who deserve the legacy behaviors), are also the
most skilled ones, so it is easier for them to add some lines to their
config, than for new users that we don't want to scare the first day
with Lisp.

>
>> This argument doesn't fly with users, because
>> newcomers usually need just one language, but
>> they need a good support for it. They will go
>> away if we don't have it, and telling them we
>> support a dozen others will not make them
>> change their minds.
>>
Sometimes new users also mix languages, but the worst supported ones are
the newer languages (Lua, Julia, Ruby, Python, C++ 11+, Rust) Which are
also what they need more often.

>> To keep Emacs alive and kicking for the
>> observable future, we need to be sure we will
>> have enough developers and contributors.
>> And since developers and contributors start
>> as users, we want to attract new users. If we
>> fail to attract them, we will quite literally
>> lose our future.
>
>OK, good point.

But also there is the fact that we are spending a lot of
effort/work/manpower in specific use cases and fancy functionalities
(web browsing, pdf reader, image shower) instead of looking and
prioritizing the general and basic editor functionalities (faster
movements commands, default bindings for comment/uncomment, select whole
line, infrastructure performance). So going to the specifics instead of
the generals.

AFAIR emacs started (and became popular) cloning the popular
functionalities in other editors and making them accessible with simple
macros. 

We just need to open sublime or athom or VS code and look all the
functionalities they provide for EDITING TEXT 2 clicks (or key binds)
far. That's the real reason of their success. Basic functionality out
of the box.

What happens now is that if a user wants a simple editor with
indentation support and syntax highlight for multiple languages, they go
for vim (it is there already, is small and has many commands for editing
text quickly, and the learning curve is similar than for emacs and much
faster/responsive). Else, if they want something advanced, then they go
for an ide or a simpler (more familiar) editor that they can start using
without reading or configuring anything, geany, athom, sublime, visual
studio code. But if the project is big with autotools or cmake they just
go for a bigger ide like kdevelor, qtcreator, eclipse, NetBeans with a
better autocompletion, debugger, compiler, packer.

Lets say for example: sublime is extensible with a simpler language
(than (lisp)) that many people use these days, it is pretty by default,
and supports many languages. It works good enough, the code is on
github, the issues, pull requests and collaboration in general is
without an arcane mailing list, and a familiar fork-joing approach. So
from the point of view of a 20 yo developers "why to us emacs?" (It is a
rhetoric context question, please don't reply to it in your answers)

So the good thing is that emacs can provide all this, but is doesn't to
have all that working it needs years (literally) of
configurations/packages. Is that what a user will chose having easier
alternatives?

>
>
>Well, obviously you worked on much bigger
>projects than I, but I did a university project
>(check out the URL in my signature). The report
>- compiled LaTeX and Biblatex, which I wrote in
>Emacs - is 153 pages. I used C++, Lisp, zsh,
>gnuplot, groff, and pic(1), and wrote all of
>that in Emacs. Even the Makefile and several
>textfiles :)
>
>So how large should a project be before Emacs
>becomes insufficient? A Quake? If so, then no,
>regretfully I wasn't part of the team...

The problem is that (in my opinion) we lost the center of what emacs
should be and where are the practical-sustainable-maintainable limits a
long time ago (the difference between "we can" vs "we should").

The program grow an grow and grow and the
unused/old/substituted/unsuccess functionalities weren't deleted.

(We added the GUI over the TUI mixing everything and adding support for
every single detail we could imagine, multi os support forced to
implement everything generic.) And as a plus the Elisp language and
interpreter, two more things to maintain and update.

To maintain-support all that with (every time) less people, we have
abandoned (not improved) the editor-ide functionalities, and the world
continued moving in the mean time. (Also some needed changes have been
delayed and arrived veeeery late because "we shouldn't convert emacs in
the other editors" or similar opinions.

So, as usual in technology, other products filled the hole thinking in
the final user and not in the developers. So, in spite of our product is
better we don't find users for it because we don't know how to present
it to the new market.



^ permalink raw reply	[flat|nested] 298+ messages in thread
* Re: Is Elisp really that slow?
@ 2019-05-16  1:32 Ergus
  2019-05-22  7:13 ` Emanuel Berg
  0 siblings, 1 reply; 298+ messages in thread
From: Ergus @ 2019-05-16  1:32 UTC (permalink / raw)
  To: help-gnu-emacs

> > So... I am scared now to be sincere here...
> > but yes. That's better (and more logical)
> > than confusing and scare the users.
> 
> Again this talk about scaring the users.
> Are computer people so darn afraid and fragile
> these days? Without boasting, let me boast that
> when I started Emacs the very first time,
> I wasn't the least scared, in fact I thought it
> was awesome, including the Lisp part, and
> I have used it ever since.
> 
Times has changes, developers too, alternative software grows like
mushrooms. What we used to do exceptionally better than the rest, now is
provided more or less by many other applications. The user experience is
different now and the needs too. Projects are bigger and more complex,
they mix languages constantly (just thin in Javascript+PHP+ASP+SQL+CSS),
languages are more complex... The choice to use a tool is based on how
more productive and easy to use it is, not in how powerful it is after
3000 lines of configuration and reading 5000 pages manual and learning
another programming  language.

Also there is a baseline already that the 99% of the users are use do
things differently (copy, paste, mouse wheel behavior, rectangular
selection, save, search, undo-redo) and the users don't want (and it
actually does not make too much sense) switch to M-w C-y and so on if
they already know a method that works for their browser, their games and
their chats.

So yes, they feel scared when they type emacs and they don't know how to
exit, or how to copy, paste, or search text with C-f, or save with
C-s... Suppose that even after that they persist and after 2 hours
reading a manual and a tutorial they try to comment a line in Python
mode with C-c C-c because they saw that it works for a c program in
stack overflow, or try to copy text from the minibuffer the same way they
do in the main buffer.

The user needs to see advantage over other systems/applications to feel
attracted enough to spend the initial time that emacs requires and deall
with the uncommon issues. In 1992 there were less alternatives around
and most of them were uglier, notably more limited or most
expensive. But in 2019 there are cheaper, prettier and free
alternatives. They are not as powerful as emacs, but they are more
ergonomic and do the work and include small details to make the life
easier||simpler||faster out of the box.
> 
> > If everything is organized in advance it will
> > be, actually it may simplify and reduce a lot
> > of redundant code, reduce the manual (good
> > for developers and the users because will
> > need to read less to start working), avoid
> > conflicts in the mailing list (and
> > discussions like this). Help external
> > developers to provide better packages at leas
> > more organized and standard without conflicts
> > with the internal functionalities.
> 
> ??? All that will happen from changing a bunch
> of keybindings?

If all the section modes in the manuals could remove the repeated (non
specific) commands and bindings that now they have to specify because
everything is disordered from their sections, the modes don't have to
include the explicit binding from them, The users don't need to learn
different commands in every different mode and the packages developers
had a clear set of reserved bindings to avoid. Yes all this will in some
degree happen.

But as you can see, it is not "a bunch" of keybindings. Ans something I
am pretty sure will never happen.




^ permalink raw reply	[flat|nested] 298+ messages in thread
* Re: Is Elisp really that slow?
@ 2019-05-16  1:19 Ergus
  2019-05-20 11:32 ` Emanuel Berg
  0 siblings, 1 reply; 298+ messages in thread
From: Ergus @ 2019-05-16  1:19 UTC (permalink / raw)
  To: help-gnu-emacs@gnu.org

>Ergus wrote:
>
>> But that's the point. The common features in
>> emacs should have the same base behavior
>> independently of the mode (comment region,
>> hungry deletion indent region, send to
>> terminal (compile and execute)/ send mail/
>> commit)
>
>It is desirable but not something to worry too
>much about. Better be creative doing more
>creative stuff.
>
>Here is a list of bike tires [1]. As you see,
>there are three different systems, or four
>actually, and one has an extension one might
>say, so let's settle for 4.5 systems. And all
>those tires? Does it really make sense to have
>one 56-559 and one 54-559 tire? Perhaps not!
>But it's reality. And Emacs is also part
>of reality.
>
>But before we get lost in a principal
>discussion... Isn't what you mention the case
>already to a large extent?
>
There are already many attempts to do that (cua mode, evil, ergoemacs,
god-mode) so I am not for sure the first with these concerns but they
fail because of the incompatibilities and conflicts with other packages.

Finally the most of the new users that wants to use the terminal are
going to vim or vim like systems like spacemacs. It is not because
modal editing is better, it is because after the initial learning curve
they can just deduce most of the actions withing the schema. Also
because vim removed the bugs and inconsistencies existent in vi in spite
of many users used to exploit them.

So in the context of your example, our tire is 55 (incompatible with
everything else by far), but also it works in a special kind of bike
that needs a 50 tire on Mondays and Tuesdays, but is the user who needs
to do the changes. We need to maintain our own bikes, wheels, the
material, and as we don't have practical arguments about why we keep
that system in many cases except that it is because it is compatible
with the previous bikes we produced the last 40 years and the old users
are use to them and they already know how to fix them.

But the new users can find spare parts for the other systems anywhere,
and specialized personal in the other technologies, and they don't need
to be alert about the day of the week... So for him is an obvious
choice. Our tire is better, because it is the only tire that can change
size 2 times a week, but for him it does not represent an advantage.

>When exactly is what key doing something
>totally unexpected in your opinion?
>
>
>[1] https://dataswamp.org/~incal/bike/TIRE

-- 



^ permalink raw reply	[flat|nested] 298+ messages in thread
* Re: Why is Elisp slow?
@ 2019-05-02 21:40 Ergus
  2019-05-02 23:39 ` 조성빈
  0 siblings, 1 reply; 298+ messages in thread
From: Ergus @ 2019-05-02 21:40 UTC (permalink / raw)
  To: Eli Zaretskii; +Cc: help-gnu-emacs

One reason why people implemented everything in elisp instead of
contributing in C (or sending patches) is:

1) in many documents around it says that it is the recommended way to
extend emacs so new users (like me) think that everything is possible
that way.

2) Because emacs didn't have a C api for modules until very recently and
even with that all the infrastructure is Lisp based. (and it still needs
a LOT of documentation) 

3) It was the only available API with documentation and that didn't
require recompile all emacs and they could redistribute, share and
maintain independently without doing all the complex process to
contribute.

Probably (I have a dream) if someone decides to develop a new emacs in
2019 most of the functions and API will be made in pure and clear C (or
any other compiled language), with a full C api that gives the same
access level than what elisp gives in Emacs today (with C lists, arrays
and structs), so it will be not only faster but also simpler to extend
it with other languages like Scheme, Python, Lua, C++, rust and so
on. (There are modules projects going in that direction) And the editor
don't even need to provide a compiler or interpreter for them. (there
will be Guile/gcc/python and so on for that)

But the emacs modules need a lot of time before they can provide the
same power and access than Elisp gives these days, but most of the
infrastructure actually calls indirectly Elisp functions and create Lisp
objects, so there will be not any performance advantage in that part of
the code until it goes back to C or the Lisp->C or the JIT compilers
will be finished.

Vim, for example, added a C api for that reason, but we are talking
about a very different beast here. They don't have their own interpreter
to maintain, no duality with GUI and TUI to maintain, no Lisp objects,
bytecode, debugger... so a very different beast.  



On Thu, May 02, 2019 at 11:20:54PM +0300, Eli Zaretskii wrote:
>> From: ?scar Fuentes <ofv@wanadoo.es>
>> Date: Thu, 02 May 2019 22:12:50 +0200
>>
>> > I have no problem with people who code something for their personal
>> > use.  That's none of my concern.
>>
>> The sceneario I described was about a package maintainer, such as Org.
>
>That was exactly my gripe.  I'm saying that implementing something for
>others should be considered more seriously than just "let's code it
>because we can".
>
>> > As for convincing: that is not required.  Just put the request in the
>> > open, and be done.
>>
>> That's not a solution if you are package maintainer trying to solve a
>> performance problem within a given time frame.
>
>Of course it is: with the Lisp implementation already in place, you
>don't need to wait for anyone or anything.  But requesting a feature
>in addition to that does two things: (a) it alerts others, including
>Emacs developers, to the need; and (b) it announces load and clear
>that the package maintainer is not really happy with the current
>solution.  Without such a request, no one will even know that there's
>a problem here waiting for a volunteer.
>



^ permalink raw reply	[flat|nested] 298+ messages in thread
[parent not found: <<878sv7sp3r.fsf@telefonica.net>]

end of thread, other threads:[~2019-06-25 16:48 UTC | newest]

Thread overview: 298+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2019-05-14 23:54 Is Elisp really that slow? Ergus
2019-05-15 11:57 ` Emanuel Berg
2019-05-15 13:06 ` Dmitry Gutov
2019-05-15 13:25   ` Óscar Fuentes
2019-05-15 13:30     ` Dmitry Gutov
2019-05-15 14:18       ` Óscar Fuentes
2019-05-15 14:45         ` Dmitry Gutov
2019-05-15 15:14           ` Óscar Fuentes
2019-05-15 15:39             ` Dmitry Gutov
2019-05-15 15:51               ` Óscar Fuentes
2019-05-15 16:05                 ` Óscar Fuentes
2019-05-15 16:07                   ` Dmitry Gutov
2019-05-15 16:05                 ` Dmitry Gutov
2019-05-15 16:12                   ` Óscar Fuentes
2019-05-15 16:15                     ` Dmitry Gutov
2019-05-15 20:23                       ` Óscar Fuentes
2019-05-15 20:30                         ` Dmitry Gutov
2019-05-15 15:42             ` Stefan Monnier
2019-05-15 17:29               ` Drew Adams
2019-05-15 19:38                 ` Ergus
2019-05-15 19:53                   ` Drew Adams
2019-05-15 20:09                     ` Ergus
2019-05-15 23:24                       ` Emanuel Berg
2019-05-15 20:46             ` Ergus
2019-05-15 23:30               ` Emanuel Berg
2019-05-15 23:12             ` Emanuel Berg
2019-05-15 19:47           ` Ergus
2019-05-15 19:45         ` Ergus
2019-05-15 15:18     ` Stefan Monnier
2019-05-15 15:34       ` Óscar Fuentes
2019-05-15 15:51         ` Stefan Monnier
2019-05-15 17:30           ` John Yates
2019-05-15 19:29             ` Ergus
2019-05-15 20:15   ` Ergus
2019-05-15 20:21     ` Dmitry Gutov
2019-05-15 20:57       ` Ergus
2019-05-15 21:00         ` Dmitry Gutov
2019-05-15 21:17           ` Ergus
2019-05-17 11:09             ` Dmitry Gutov
2019-05-15 15:07 ` Uniformity (was: Is Elisp really that slow?) Stefan Monnier
2019-05-15 15:24   ` Uniformity Óscar Fuentes
2019-05-15 15:45     ` Uniformity Stefan Monnier
2019-05-15 19:58   ` Uniformity (was: Is Elisp really that slow?) Ergus
2019-05-18 23:51   ` Emanuel Berg
2019-05-15 15:14 ` Is Elisp really that slow? Eli Zaretskii
2019-05-15 15:40   ` Óscar Fuentes
2019-05-15 16:14     ` Eli Zaretskii
2019-05-15 16:23       ` Tadeus Prastowo
2019-05-15 16:27         ` tomas
2019-05-15 17:00         ` Eli Zaretskii
2019-05-15 20:09           ` Óscar Fuentes
2019-05-16 13:12             ` Eli Zaretskii
2019-05-16 13:40               ` Óscar Fuentes
2019-05-16 14:06                 ` Eli Zaretskii
2019-05-15 21:09       ` Ergus
2019-05-16 14:12         ` Eli Zaretskii
2019-05-16 16:14           ` Ergus
2019-05-16 17:46             ` Eli Zaretskii
2019-05-16 20:23               ` Ergus
2019-05-16 20:50                 ` Óscar Fuentes
2019-05-16 22:46                   ` Ergus
2019-05-16 23:19                     ` Óscar Fuentes
2019-05-28 21:08                     ` Emanuel Berg via help-gnu-emacs
2019-05-28 21:50                       ` Drew Adams
2019-05-17  1:28                   ` Jean-Christophe Helary
2019-05-17  2:26                     ` Óscar Fuentes
2019-05-17  4:05                       ` Jean-Christophe Helary
2019-05-17  6:08                         ` Ergus
2019-05-17  9:21                           ` tomas
2019-05-17 14:01                             ` Óscar Fuentes
2019-05-17 14:16                               ` Dmitry Gutov
2019-05-17 14:50                                 ` Óscar Fuentes
2019-05-17 18:19                                   ` Dmitry Gutov
2019-05-17 19:23                                     ` Óscar Fuentes
2019-05-17 20:51                                       ` Dmitry Gutov
2019-05-17 16:37                                 ` tomas
2019-05-17 16:50                                   ` Óscar Fuentes
2019-05-17 17:05                                     ` Óscar Fuentes
2019-05-17 18:11                                       ` Dmitry Gutov
2019-05-17 18:16                                     ` Dmitry Gutov
2019-05-17 18:14                                   ` Dmitry Gutov
2019-05-30 12:09                               ` Emanuel Berg via help-gnu-emacs
2019-06-25 16:48                                 ` Jean Louis
2019-05-29  4:58                           ` Emanuel Berg via help-gnu-emacs
2019-05-17 13:46                         ` Óscar Fuentes
2019-05-29  4:26                         ` Emanuel Berg via help-gnu-emacs
2019-05-17  5:52                       ` Ergus
2019-05-17  9:01                         ` Eli Zaretskii
2019-05-17 12:35                           ` Ergus
2019-05-17 13:13                             ` Eli Zaretskii
2019-05-17 13:22                               ` Dmitry Gutov
2019-05-17 13:39                                 ` Eli Zaretskii
2019-05-17 15:07                                   ` Óscar Fuentes
2019-05-18 15:41                                     ` Dmitry Gutov
2019-05-17 15:39                                   ` Ergus
2019-05-17 15:47                                     ` Noam Postavsky
2019-05-17 15:48                                     ` Eli Zaretskii
2019-05-17 19:24                               ` Ergus
2019-05-17 20:12                                 ` Eli Zaretskii
2019-05-19 13:38                                   ` Ergus
2019-05-19 13:42                                     ` Noam Postavsky
2019-06-06  3:24                                     ` Emanuel Berg via help-gnu-emacs
2019-06-05  6:05                                   ` Emanuel Berg via help-gnu-emacs
2019-06-05  4:44                                 ` Emanuel Berg via help-gnu-emacs
2019-06-06 21:06                                   ` Xavier Maillard
2019-06-07 19:01                                     ` Emanuel Berg via help-gnu-emacs
2019-05-31 15:50                               ` Emanuel Berg via help-gnu-emacs
2019-05-31 17:57                                 ` Eli Zaretskii
2019-06-07 18:46                                   ` Emanuel Berg via help-gnu-emacs
2019-06-02 10:49                                 ` Stefan Huchler
2019-06-02 19:16                                   ` Marcin Borkowski
2019-06-02 22:49                                     ` Stefan Huchler
2019-06-07 18:55                                     ` Emanuel Berg via help-gnu-emacs
2019-06-07 18:53                                   ` Emanuel Berg via help-gnu-emacs
2019-05-17 14:21                             ` Óscar Fuentes
2019-05-17 15:02                             ` Drew Adams
2019-05-17 16:29                           ` Stefan Huchler
2019-05-17 17:19                             ` Ergus
2019-06-05  2:29                               ` Emanuel Berg via help-gnu-emacs
2019-06-04 22:29                             ` Emanuel Berg via help-gnu-emacs
2019-05-30  3:30                           ` Emanuel Berg via help-gnu-emacs
2019-05-17 14:12                         ` Óscar Fuentes
2019-05-17  8:54                       ` Dmitry Gutov
2019-05-17  9:36                         ` Eli Zaretskii
2019-05-17 11:09                           ` Dmitry Gutov
2019-05-17 12:04                             ` Eli Zaretskii
2019-05-17 12:56                               ` Ergus
2019-05-17 13:31                                 ` Eli Zaretskii
2019-05-17 15:03                                 ` Drew Adams
2019-06-04  1:27                                   ` Emanuel Berg via help-gnu-emacs
2019-05-31 19:03                                 ` Emanuel Berg via help-gnu-emacs
2019-06-01  8:17                                   ` Jean Louis
2019-06-07 18:49                                     ` Emanuel Berg via help-gnu-emacs
2019-05-17 13:17                               ` Dmitry Gutov
2019-05-17 13:35                                 ` Eli Zaretskii
2019-05-17 13:43                                   ` Dmitry Gutov
2019-05-17 14:36                                     ` Eli Zaretskii
2019-05-18 16:54                                       ` Dmitry Gutov
2019-05-18 17:17                                         ` Eli Zaretskii
2019-05-18 22:43                                           ` Dmitry Gutov
2019-05-18 23:54                                             ` Óscar Fuentes
2019-05-19  0:24                                               ` 조성빈
2019-05-19  5:24                                                 ` Óscar Fuentes
2019-05-19 15:18                                                   ` Stefan Huchler
2019-05-19 18:40                                                     ` Óscar Fuentes
2019-05-20  6:47                                                       ` tomas
2019-05-20 14:57                                                         ` Drew Adams
2019-05-20 15:28                                                         ` Óscar Fuentes
2019-06-06  5:16                                                           ` Emanuel Berg via help-gnu-emacs
2019-05-21 12:19                                                         ` Van L
2019-05-23 20:01                                                     ` Robert Thorpe
2019-05-23 23:05                                                       ` Stefan Huchler
2019-05-24 14:40                                                         ` Robert Thorpe
2019-05-25  0:07                                                           ` Stefan Huchler
2019-05-25 10:54                                                             ` Robert Thorpe
2019-06-06  6:02                                                       ` Emanuel Berg via help-gnu-emacs
2019-06-06  0:16                                                     ` Emanuel Berg via help-gnu-emacs
2019-06-06  0:08                                                   ` Emanuel Berg via help-gnu-emacs
2019-06-06  0:06                                                 ` Emanuel Berg via help-gnu-emacs
2019-05-19  2:40                                             ` Eli Zaretskii
2019-05-31 21:04                                       ` Emanuel Berg via help-gnu-emacs
2019-05-31 15:05                               ` Emanuel Berg via help-gnu-emacs
2019-05-17 14:40                             ` Óscar Fuentes
2019-06-02  2:00                               ` Emanuel Berg via help-gnu-emacs
2019-05-19 18:35                           ` Stefan Monnier
2019-05-19 19:23                             ` 조성빈
2019-05-20  6:53                             ` tomas
2019-06-06  5:03                             ` Emanuel Berg via help-gnu-emacs
2019-06-11 13:06                             ` Ergus via help-gnu-emacs
2019-06-11 13:37                               ` Óscar Fuentes
2019-06-12  1:08                                 ` Ergus via help-gnu-emacs
2019-05-30 21:30                           ` Emanuel Berg via help-gnu-emacs
2019-05-30 21:25                         ` Emanuel Berg via help-gnu-emacs
     [not found]                       ` <<20190517055202.ted62gt6hqcip7xt@Ergus>
     [not found]                         ` <<83mujlbgjh.fsf@gnu.org>
2019-05-17 15:03                           ` Drew Adams
2019-06-04  1:20                             ` Emanuel Berg via help-gnu-emacs
2019-06-04  1:50                               ` Emanuel Berg via help-gnu-emacs
2019-05-28 23:16                       ` Emanuel Berg via help-gnu-emacs
2019-05-17  9:05                     ` tomas
2019-05-28 21:54                     ` Emanuel Berg via help-gnu-emacs
2019-05-17  8:47                   ` Dmitry Gutov
2019-05-17 15:22                     ` Óscar Fuentes
2019-05-17 18:28                       ` Dmitry Gutov
2019-05-17 19:55                         ` Óscar Fuentes
2019-06-04  1:41                           ` Emanuel Berg via help-gnu-emacs
2019-06-04  1:38                         ` Emanuel Berg via help-gnu-emacs
2019-06-04  1:37                       ` Emanuel Berg via help-gnu-emacs
2019-05-31  3:36                     ` Emanuel Berg via help-gnu-emacs
2019-05-17  8:55                   ` tomas
2019-05-17 15:02                     ` Drew Adams
2019-05-31  4:52                       ` Emanuel Berg via help-gnu-emacs
2019-05-27 14:30                   ` Emanuel Berg via help-gnu-emacs
2019-05-29  5:02                     ` Xavier Maillard
2019-06-07 18:40                       ` Emanuel Berg via help-gnu-emacs
2019-05-17  6:24                 ` Eli Zaretskii
2019-05-30 17:58                   ` Emanuel Berg via help-gnu-emacs
2019-05-25  8:22                 ` Emanuel Berg via help-gnu-emacs
2019-05-25  9:05                   ` 조성빈 via help-gnu-emacs
2019-05-25  5:14               ` Emanuel Berg via help-gnu-emacs
2019-05-25  4:42           ` Emanuel Berg via help-gnu-emacs
2019-05-25  6:31             ` Eli Zaretskii
2019-06-07 18:34               ` Emanuel Berg via help-gnu-emacs
2019-06-07 20:21                 ` Eli Zaretskii
2019-05-19  0:03         ` Emanuel Berg
2019-05-19  8:16           ` Van L
2019-05-19 10:35             ` 조성빈
2019-05-19 12:48               ` Van L
2019-05-19 13:13                 ` Ergus
2019-06-06  2:54                   ` Emanuel Berg via help-gnu-emacs
2019-05-19 13:00               ` Ergus
2019-05-19 14:57                 ` 조성빈
2019-06-06  3:08                   ` Emanuel Berg via help-gnu-emacs
2019-05-19 13:05               ` Ergus
2019-05-21 12:00                 ` Van L
2019-06-06  3:20                   ` Emanuel Berg via help-gnu-emacs
2019-06-06  0:52               ` Emanuel Berg via help-gnu-emacs
2019-06-06  0:53               ` Emanuel Berg via help-gnu-emacs
2019-05-19 14:32             ` Drew Adams
2019-05-21 12:09               ` Van L
2019-06-06  0:43             ` Emanuel Berg via help-gnu-emacs
2019-06-06  2:12               ` Drew Adams
2019-05-23 20:16           ` Robert Thorpe
2019-06-07 18:23             ` Emanuel Berg via help-gnu-emacs
2019-06-08 20:12               ` Robert Thorpe
2019-06-09 13:37                 ` Tomas Nordin
2019-06-09 13:50                   ` tomas
2019-06-10 22:55                     ` Emanuel Berg via help-gnu-emacs
2019-06-12  9:16                       ` [offtopic] " Van L
2019-06-12  9:28                         ` tomas
2019-06-12 11:31                           ` Van L
2019-06-12 11:44                             ` tomas
2019-06-14  4:12                           ` Xavier Maillard
2019-06-14  7:07                           ` tomas
2019-06-12 11:16                         ` [offtopic] " Jean-Christophe Helary
2019-06-12 13:28                           ` Van L
2019-05-16 23:31   ` Emanuel Berg
  -- strict thread matches above, loose matches on Subject: below --
2019-05-16  1:32 Ergus
2019-05-22  7:13 ` Emanuel Berg
2019-05-16  1:19 Ergus
2019-05-20 11:32 ` Emanuel Berg
2019-05-02 21:40 Why is Elisp slow? Ergus
2019-05-02 23:39 ` 조성빈
2019-05-03  0:44   ` Ergus
2019-05-10 13:14     ` Van L
2019-05-10 13:22       ` Michael Heerdegen
2019-05-11  0:38         ` Emanuel Berg
2019-05-11  7:32           ` Is Elisp really that slow? (was: Why is Elisp slow?) tomas
2019-05-11  7:42             ` 조성빈
2019-05-11  7:57               ` tomas
2019-05-11 23:09                 ` Emanuel Berg
2019-05-12  7:54                   ` tomas
2019-05-12  9:46                     ` 조성빈
2019-05-12 14:21                       ` Eli Zaretskii
2019-05-12 14:45                         ` Is Elisp really that slow? Óscar Fuentes
2019-05-12 15:28                           ` Eli Zaretskii
2019-05-12 15:46                             ` Óscar Fuentes
2019-05-12 17:20                               ` Eli Zaretskii
2019-05-12 18:37                                 ` Óscar Fuentes
2019-05-12 18:53                                   ` Eli Zaretskii
2019-05-13  1:44                                     ` Emanuel Berg
2019-05-12 21:18                                   ` Stefan Monnier
2019-05-12 22:22                                     ` Óscar Fuentes
2019-05-14 13:39                                       ` Stefan Monnier
2019-05-14 15:09                                         ` Óscar Fuentes
2019-05-13  0:57                                     ` Samuel Wales
2019-05-13 12:37                                       ` Stefan Monnier
2019-05-13 14:23                                         ` Emanuel Berg
2019-05-13 14:33                                         ` Emanuel Berg
2019-05-14  8:24                                           ` tomas
2019-05-14 13:21                                             ` Emanuel Berg
2019-05-14 14:44                                               ` tomas
2019-05-15 11:25                                                 ` Emanuel Berg
2019-05-15 12:05                                                   ` tomas
2019-05-15 23:02                                                     ` Emanuel Berg
2019-05-16  6:48                                                       ` tomas
2019-05-16  9:37                                                         ` Noam Postavsky
2019-05-16 11:02                                                           ` tomas
2019-05-23 14:23                                                             ` Emanuel Berg
2019-05-24  1:33                                                               ` Van L
2019-05-16 13:31                                                       ` Eli Zaretskii
2019-05-23 14:28                                                         ` Emanuel Berg
2019-05-23 14:54                                                           ` Drew Adams
2019-05-23 14:55                                                           ` Eli Zaretskii
2019-06-06  5:18                                                             ` Emanuel Berg via help-gnu-emacs
2019-05-16 14:45                                                   ` Stefan Monnier
2019-05-25  4:53                                                     ` Emanuel Berg via help-gnu-emacs
2019-05-13  1:52                                     ` Emanuel Berg
2019-05-13  1:35                                   ` Emanuel Berg
2019-05-12 21:01                               ` Stefan Monnier
2019-05-13  1:27                             ` Emanuel Berg
2019-05-13 14:38                               ` Eli Zaretskii
2019-05-13 15:00                                 ` Emanuel Berg
2019-05-13 15:25                                   ` Eli Zaretskii
2019-05-14 11:54                                     ` Emanuel Berg
2019-05-14 16:21                                       ` Eli Zaretskii
2019-05-14 17:05                                         ` Emanuel Berg
2019-05-14 18:30                                           ` Eli Zaretskii
2019-05-15 11:27                                             ` Emanuel Berg
2019-05-15 14:51                                               ` Eli Zaretskii
2019-05-16 23:19                                                 ` Emanuel Berg
2019-05-17  6:41                                                   ` Eli Zaretskii
2019-05-13 15:02                                 ` John Yates
2019-05-13 15:14                                   ` Eli Zaretskii
2019-05-13 22:40                                 ` Dmitry Gutov
2019-05-14  6:27                                 ` Paul W. Rankin
2019-05-14 13:10                                   ` Emanuel Berg
2019-05-13 15:42                               ` Van L
2019-05-17 15:17                           ` Ken Goldman
2019-06-04  1:36                             ` Emanuel Berg via help-gnu-emacs
2019-06-08  0:26             ` Is Elisp really that slow? (was: Why is Elisp slow?) Samuel Wales
2019-06-08  8:52               ` tomas
2019-06-08 21:00                 ` Samuel Wales
2019-06-08 21:14                   ` tomas
2019-06-08 21:44                     ` Is Elisp really that slow? Óscar Fuentes
2019-06-08 23:29                       ` Emanuel Berg via help-gnu-emacs
2019-06-11  4:10                       ` Xavier Maillard
     [not found] <<878sv7sp3r.fsf@telefonica.net>

Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/emacs.git
	https://git.savannah.gnu.org/cgit/emacs/org-mode.git

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.