Free as in breathing, free as in drinking water. Code is such an integral part of life that it is unthinkable that we cannot have control over it. Emacs gives you control, it gives you freedom.
I am amazed how Stallman got it right and invented on his principles. Thank you Dr. Stallman, thank you.
rms has a doctorate? Or is this some sort of honorific I've never heard before?
Some say Atom and VSCode also have plugins. That's true, but can you write code to extend some VSCode functionality in a minute?
You just go to the scratch buffer, write some code, evalute it and it instantly becomes part of the editor. I don't know if there are other editors which can replicate this experience.
That said, VS Code isn’t as flexible—there’s a distinction between building VS Code and building an extension, and the two aren’t equivalent. The closest analogy I can think of is developing an old-fashioned XUL Firefox extension vs a new Chrome-style extension. The former used the same building blocks the app used, the latter was intentionally sandboxed and sanitized.
That said, you can do a heck of a lot with VS Code extensions, enough that I don’t want to install any I don’t trust —they can run programs and never prompt you for permissions, etc. So with great power comes great responsibility ;-)
And it could be argued that in a perfect world, VS Code should have both a live-edit-and-reload experience for plugin development alongside a more formal, sandboxed approach with signing and permissions and everything.
Doesn't Emacs have the same issue - you really really have to trust any package you install?
That's irrelevant: what matters is the value of an attack vector. e.g. Bill Gates is a small attack vector.
Attack the high value of some developers assets, or attack the high value of some of the businesses they work for.
Because it's lisp you can inspect just about everything. See an unfamiliar symbol? Put your cursor on it and press M-.
0: launch help from within Emacs
In the HyperCard thread on the front page right now (https://news.ycombinator.com/item?id=20550189), someone linked a talk (https://www.youtube.com/watch?v=9nd9DwCdQR0&feature=youtu.be...) on the history of educational software, and one of the presenters said something like, "Some technologies we are simply not mature enough for."
I think this is not a bad description of "the Lisp Curse." I definitely wasn't mature enough for Lisp when I first learned it---high on my knowledge of what was possible, surrounded by myopic fools, as I thought.
But that was years ago. I'm mature enough now. It is possible.
In my consulting work my partner and I have marveled at how managing technology projects is a skill --- learnable, but only with some effort and practice, and carrying relatively heavy requirements of being technically competent and having a context of the business.
That's the skill that's needed, IMO, to make Lisp "work." Lisp itself---and Clojure---are really not complicated languages. My boss teaches them to undergrads and they can be productive fairly quickly. They are complicated when someone has built a crappy, leaky tower of abstractions on them. Recognizing when you're in danger of doing so, and when it's not worth it given other factors (business value, maintainability, etc) is the key.
So I wonder, idly, if metaprogramming---no, really, the meta of programming, like "Don't Call Yourself A Programmer" (https://www.kalzumeus.com/2011/10/28/dont-call-yourself-a-pr... ) and "Developer Hegemony" (https://www.amazon.com/Developer-Hegemony-Erik-Dietrich/dp/0... )---might develop some more, esp. among the Lisp communities. When the language is no longer the barrier, you start to realize that other things are.
It’s probably possible today to write an Emacs in a high-performance Lisp.
Elisp has no support for concurrency, for example.
“Some 359,000 lines of C code comprise its kernel, and 1,637,000 lines of Emacs Lisp take the rest of it.1”
43 years ago Emacs wasn't written in C or Lisp. It was first just a bunch of TECO code, and TECO was written in assembler (I still have the source on my bookshelf).
In fact none of the first three machines to have Emacses (PDP-10, Multics, and the CADR Lispm) supported C. (C was eventually ported to the PDP-10/KL-20 but C can't really represent those machines very well. C was really designed for a specific, restricted kind of architecture, one that is popular today).
So, would you just say around 38 years and agree that 43 or 38 is pretty much irrelevant to my point?
I don't think emacs should be made any slower than it already is.
Then there is something wrong with your environment. Emacs has no problems with big files. It can have problems with very long lines, but big files shouldn't slow it down.
But, 2000 lines are really not that much. Usually problems on my systems start to show at >10k lines.
Not exactly related but with Emacs 27 will be distributed the so-long mode that could toggle minor modes that affect redrawing like "font-lock", "visual-line", "whitespace" when files with long lines are opened: https://git.savannah.nongnu.org/cgit/so-long.git/plain/so-lo...
The emacs developers will be very interested to hear about it.
Also, I disagree about the 'lisp makes people selfish'. It may be true at first, but I dearly believe that every long time lisper on earth is totally aware of that and knows where to draw the line. It's been discussed to death early on and regularly since. We all enjoy the freedom to fool depth first into every idiosyncratic itch we think of, but we know that they're most of the time only that. And that others can give different views on a similar problem, yielding a more generic notation/solution by blending all attempts.
It does cost a bit though, for instance scheme lack of standard module (until recently IIUC) forces one to work a bit more, or maybe port by hand. But very often, lisp libs are tiny. I still remember the article from early 2ks about a guy searching for graph libraries in java. Found 3, none of them was good enough, in the end he wrote his own in CL in a day. There's a cost of sharing too.
But I use Emacs as a mail client—message mode is awesome—and extended it with a procedure to create text/html parts and all the necessary MIME headers. I especially like using that for tables that are readable in monospaces text/plain or as HTML tables. Compare that to a GUI mail editor, which surely defaults to HTML but which probably isn’t going to offer you tabular support.
Let’s see. I have some fine control over white space in here, to meet different collaborator’s guidelines. And that integrates with the magit git front end.
I have a bunch of macros driven by the abbrev autocorrect scheme.
But in reflecting on this, the big important category is “Other”. I write 5-50 line programs, sometimes starting from a macro recording of one run of the core loop, weekly.
Imagine a world where general spreadsheets didn’t exist; you had accounting software but it was all like TurboTax or quickbooks, very hard wired for a purpose. And imagine asking how users of Excel customized their workflows, as they tried to explain that the point was the total flexibility. Emacs is like that for text files.
However the tooling for VS Code is absolutely nothing like the Emacs REPL (however disclaimer: I haven't used Emacs for a very long time)
So big caveat: my experience with Emacs is pretty much entirely limited to org-mode (which is the only reason I picked up Emacs at all). I really liked a lot of the ideas in org-mode, but the more I used it the more I really wanted to make some minor tweaks. No problem, I thought. Emacs is famous for being super customizable. But everything I touched was extremely brittle, and essentially impossible to configure to work as I wanted it to.
1. Wasn't a huge fan of "\star" "\star\star" "\star\star\star" as the headlines. I would prefer "\t\star" "\t\t\star" "\t\t\t\star". Hmm, seems the only way to do this is a hack that changes the leading stars to the same color as my Emacs background. That's kind of hack-y. The rationale I could find for this was to keep a consistent on disk format. I guess that makes sense, though it's not something I care about ... I don't intend on sharing my TODO list (and my understanding is there's no 100% compatible org-mode parser outside of Emacs anyway). Not a big deal, I'll live with it.
2. Agenda view. As I started using org-mode more and more for task management I decided I needed a good task view. I set my own task and project states (nice: simple, works) then I set to work on creating a nice view of all my tasks organized in separate sections (REFILE tasks, active projects, active tasks). Hmm, now it takes multiple seconds to refresh my agenda view. And I have to manually refresh it any time I make a change to any file ... This kinda sucks. Might be a solution for this, never got around to investigating.
3. File structure for my org files. Despite the occasional org-mode article on Hacker News, it's actually pretty hard to find good examples of a full org-mode workflow. When I was actively working on this I found one or two. When writing my org files I kept running in to the odd problem with certain features because of how I was laying out my files. Should there be an empty line after a headline? Are paragraphs separated by empty lines? If you don't do this correctly (and since there's so few examples available, "correctly" is something you have to figure out by trial and error) then certain exporters (pdf, html) don't give correct output, or folding doesn't work.
4. Directory structure of my org files repo. I like being aggressive about breaking things up in to different files. And then organizing these files in to different directories. New project? New directory, new project org file. Let's make a separate file for research. So <PROJECT DIR>/Research.org. Unfortunately this butts up with how org-mode assumes you have things organized (which again, you can only really figure out by trial and error when things don't work). Take REFILE for example. It tab completes by file name. But problematically I now have a lot of files with similar names (e.g. Research.org) in different directories. org-refile-use-outline-path sort of fixes this but it's still clunky.
5. Emphasis. The straw that broke the camel's back. All of the above were minor and I kept with org-mode. It sorta worked. But I was annoyed. Eventually I started doing some research that involved quotes where I really wanted to basically highlight phrases or sentences that were important. I figured this would either be built-in to org-mode or easily added in my Emacs conf. I never did find a solution that actually worked. I can underline, italicize, bold, etc, but no highlight (i.e. classic yellow background for text). Apparently org-mode deliberately prevents the end user from adding their own custom emphasis formats in order to have a consistent file format.
At this point I left org-mode and emacs all together and ended up writing my own rich text editor so I could do whatever formatting I wanted. It doesn't do 1% of what org-mode can, but dammit I can highlight in 6 different colors.
I'm disappointed I never got to experience the Emacs nirvana that all these articles describe. Maybe it's just org-mode, but everything I touched seemed extremely brittle. Felt very much like I was forced to do it the org-mode way. It was really disappointing.
Observation on point, and ironically it limits the ability for developers to tweak third-party software (what if you want to change some aspect _in the middle_ of the large code gob?)
Yi, in Haskell.
Take away the Lisp and you are already very unlike Emacs.
Elixir is one that comes to mind (It has the "big" Lisp things, like hygienic macros).
Actually, Erlangs concurrency model might well work very well for emacs, since you can spawn off hundreds of independent tasks with close to zero overhead, and use all available cores to run them on.
I'm pretty sure that if I found myself doing development on my editor then this would be a form of procrastination because modifying the editor certainly ain't developing product related functionality. For me it's more effective to ignore or work around failings in my editor, or better yet, invest some time in trying to learn in more depth the functionality that is already present in my IDE that might approximately meet my need.
It's actually on anyone who comes after.
That might be just me, or if the code is public it could be anyone.