Lisp and Scheme are marvelous 60s-70s hippie acid-head languages. “Hey, let’s use a small set of primitives and treat code and data the same and we can run huge worlds with a tiny, recursive interpreter!”

By the time you get to Emacs though, many huge worlds have been built, and navigating the huge world(s) that small set of primitives has created can be…uh…daunting – both because of 1000s of people’s contributions and because of the weight of history (e.g. booleans are “predicates” – from calculus – thus all the “_p” names).

That said, at it’s core, it’s elegant and lovely.

https://preview.redd.it/g641rtwx502c1.jpeg?width=640&format=pjpg&auto=webp&s=1d6fe005a93830eb624d5fd0324ae97c84135f86

If you’re sold on sticking with Emacs, then learning elisp will unquestionably pay dividends, and the more you learn the more you’ll be able to do (but you don’t need to understand everything in order to do anything).

and how exactly can i improve my emacs experience if i learned elisp?

That’s the thing – it’s up to you. The ability to “scratch any itch” is what elisp give you. That doesn’t mean any given thing is easy to do (although it might be) but, to a significant extent, if you can identify a problem then implementing a solution is also a possibility.

Elisp isn’t just a programming language it’s an execution environment and it doesn’t make a lot of sense to consider them separately.

For example the largest abstraction in elisp is the buffer. A lot of core language features revolve around and are greatly modified by the buffer. For example variable bindings can typically be overrides in buffer-local variables.

Furthermore there’s a lot of editor specifics that are interesting. Text properties are the least of which. Buffer narrowing is another. But what about… fields? Judicious use of fields limits where you can type into a buffer. Consider the customize user interface for example.

Basically emacs is a complete tui development environment.

so my question is, Is it worth it?

It’s worth more than a bunch of other people’s opinions.

“i’m not a programmer by any means” what do you use Emacs for? (sincere question, I know non-programers use Emacs)

It’s sort of a silly question.

To customise emacs beyond clicking around in ‘customise’ you need to write elisp. If you learn little elisp then you can only customise it using other people’s code, if you learn a lot of it then you can write an mua.

You decide where you want to be on that spectrum.

Let me cite RMS to answer that:

The editor itself was written entirely in Lisp. Multics Emacs proved to be a great success—programming new editing commands was so convenient that even the secretaries in his office started learning how to use it. They used a manual someone had written which showed how to extend Emacs, but didn’t say it was a programming. So the secretaries, who believed they couldn’t do programming, weren’t scared off. They read the manual, discovered they could do useful things and they learned to program.

source: https://www.gnu.org/gnu/rms-lisp.html

Programming in elisp is fun, too. Since it’s (typical for Lisp!) interactive programming features.

Actually learning elips itself is the reward.

Yes. It’s worth it.

If you’ve ever tweaked your Doom config, you’re already writing elisp. Going from setting options to writing new modes will certainly take time, but lisp is a language that builds on itself.

In fact, Emacs+elisp is one of the best systems for learning by doing. C-h f, C-h v, C-x C-e, etc will get you far. The built in tutorial is absolutely worth going thru, and understanding lisp will improve your understanding of other languages as well.

Is it just me or have there been a lot of posts lately from accounts with overall negative comment karma.

Lisp (and especially Emacs Lisp) isn’t harder than other languages. I’m not a professional programmer either, but I’ve dabbled in languages from BASIC to bash to PERL, JavaScript, and Python. In my experience, Elisp has been the easiest of all of them.

Once you wrap your head around how lists work in Lisp, it all comes together pretty quickly. And Emacs’s self-documenting nature makes learning it that much easier.

The syntax is more consistent than any other language I’ve come across. It’s lists all the way down.

Just do “C-h R eintro RET” and start learning. Do “M-x find-library RET” to read the code of your favorite package and figure out how it works.

It’s pretty tiny compared to a lot of languages considering that most of what you use it for is working with Emacs, which has a small number of intrinsic types like buffers, windows, frames, text properties etc.

Compared to being the kind of person who reads use-package like JSON and treats it like a declaration language, you will be light years ahead at configuration if you just know lists, quoting, alists, plists, and writing functions. Users who don’t go at least that far will be constantly shooting themselves in the foot and spending much more time with minor, novice level bugs that are completely obvious.

Learning a new programming language is like learning a new spoken language: not only does it give you additional skills, but it gives you perspective on your “native” language. The usual way of doing things in C++ is not the best way to do things in Python or Lisp, and vice versa.

One cool feature of Lisp is that the code is the parse tree.

Well, if you want to customise Emacs - obviously it’s worth learning. Im not quite sure where you get that idea that because its “old” then its support is somehow worse than “more popular” languages. It has great documentation - in editor too.

You need surprisingly little if you already have general lisp knowledge to actually be able to write your own configs. Hell, you don’t need any knowledge just work with it as if it’s some config file grammar. I started with doom and after a year or so took a step into vanilla Emacs. My Emacs config is exactly how I want it now. Don’t get me wrong it’s not life changing compared to Doom but if you have a weekend spare and you are feeling up the challenge, give it a shot.