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.

so my question is, Is it worth it?

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

Actually learning elips itself is the reward.

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.

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.

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.

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

Emacs Lisp is probably one of my favorite and most used programming languages outside of work. Emacs is a very pleasant environment to program in, because it’s a Lisp image that you can poke and prod. I literally will do everyday math in Emacs Lisp now if I am at my computer.

Also, helpful tip: since Emacs Lisp is so old and LLMs are often based on old data, I find that tools like ChatGPT are very good at producing working Emacs Lisp.

This is helpful because I find that many Emacs functions and macros are not named in a way that is easy to search by.

Emacs Lisp was one of my first programming languages. As a physics student I had learned C++ (badly) as my first programming language, choose Emacs as an editor for that and also started using Lisp for configuration (maybe not a smart choice for productivity and in hindsight, but I had fun). Compared to an old-school compiled language I found Lisps to be easier, no worrying about types, no weird syntax, just functions (and macros). And most importantly coding in Elisp (and other Lisps) is incredibly interactive, just C-x C-e to eval any expression and see the result of any expression. For ELisp Emacs has excellent “IDE” features out of the box, you with ELdoc you see signatures of the function at point, can jump to defenitions, see docstrings etc. Also it helps that Emacs functions and variables have excellent docstrings (which the first physicist-written C++ codebases that I had worken on had not, in some cases basic Doxygen but it’s not as nice. Later I learned Python and I think it’s the better programming language today for learning how to code, and as an interpreted languages it also has some interactivity with its REPL (IPython) and Jupyter, docstring support, ducktyping etc. But I really appreciate how “friendly” Lisps are in relative terms considering how old they are, no wonder they had been used for introductory computing courses at MIT in the past. But there’s a lot of weirdness and naming conventions that seem archaic today (things like cddar).

Regarding how rewarding it is, I think very much so! In other programming languages I found it hard to find project ideas that are really useful to me in my every day. But I use an editor daily and it’s incredibly easy to find something that I’d like to tweak and I can come up with a function in a *scratch* butter, evaluate it and use it interactively or hook it to some mode for example.

Most of my coding I had done was just doing configuration and some interactive helper functions, things like adding a custom completion backend (capf) to a special mode, a confirmation warning when I forget to add an email subject and things like that. But in total I wrote more Elisp than the recreational coding I had done in most of my other programming languages.

Despite saying I studied physics in my research I leaned heavily on the coding-heavy work and am soon entering an IT job in industry, so I’m totally someone who enjoys coding. But I think Emacs gave me a slight push in that direction.

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.

I’m not in love with elisp but I learned enough of it to make emacs do what I want.

I’ll admit without shame that the for complicated stuff, I do it all in python helpers, and I just use elisp to marshall data to and from python.

A better elisp developer than me would do everything in elisp… but I need to get things done quickly and dirty.