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

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.

Actually learning elips itself is the reward.

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.

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

so my question is, Is it worth it?

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

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.

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.

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.

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.

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

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.

When I want to add an automatic garage door, I don’t go on r/ElectricalEngineering and ask how rewarding learning EE can be. I decide wtf I want to have happen, then google accordingly.

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.

It was for me.

After reading Paul Graham wax lyrical about lisp ( see essay Beating the Averages), I wanted to learn a lisp. Emacs is the most practical lisp in the sense that even a small amount of it can do something immediately useful (for emacs), and I wasn’t going to replace R / Python / Fortran with Common Lisp or Scheme for my scientific computing needs.

Not sure it expanded my mind like I had expected in the end. Apart from the homoiconicity and macros, most major ideas introduced by lisp has made its way into other mainstream languages.

But it’s a beautiful language and at least I know now that I’m not missing out on something huge, and that gives me piece of mind (maybe macros are huge and I’m toying with them in Julia at the moment).