I’ve used Emacs nearly every day since 1980/teco. I’m now on 28.1. What are the best things I’m missing?

I write and edit C, C++, PHP, Python, bash, and, rarely Java. I use the basic packages in progmodes for these languages, oftentimes using C as a base (for example, for PHP.) I’ve written a few thousand lines of elisp to do a few things I like, I use dired, calendar, shell (extended a bit so I easily have multiple shell windows.) I’ve been happy with this setup since version 18 days, with only minor subsequent tweaks. And again, I’m in it more days a week than not. So… what am I missing that adds great functionality but is more than “it does it differently, but gets pretty much the same thing done). In other words, what development since 1990 has really made an improvement?

Some people who use Emacs were not even born at the time you started use Emacs :) So, I do not think you’d find fine comparison of features since then :) From other prospective, masteringemacs is very good book about “modern” Emacs and it is very short. I’d recommend to read that one. Thanks Mickey :)

hmm... for software development, the support of LSP stands out. oh, and i started using teco-based emacs in 1979 myself :-).

Thanks! I’ll check the book out :)

The book came to my mind because there were announce recently that it was updated for Emacs 28. Additionally, on the book site you can find more articles what potentially contains some info. Especially overview of major updates.

Org, Hyperbole, Burly, Ace Windows, Avy, Counsel and the classic Supercite. Check them out.

Checkout lsp-mode, and elpy. Org mode too. I love magit and the forge extensions. GUI/Color support is also pretty good (solarized, zenburn etc).

As someone who has been using Emacs since the nineties, I'd say that the main things are Org-mode and Magit. The former is something I overlooked for far too long, even after it was bundled in with Emacs. The latter hasn't been bundled in yet, and may never be unless the FSF loosens their CLA policies, but those CLA policies are basically the *only* reason it hasn't been bundled yet. Too many contributors to track down. Org-mode is basically a crazy-flexible (of course) free-form organizer tool with insane amounts of bonus features up to and including literate programming tools. Magit is simply the best version control front end ever devised. Not just the best front end for *Emacs*\--the best front end *period.* These two are both regularly touted as killer-app-level features for Emacs, these days, and are the main reasons many people now use Emacs. A whole lot of younger folks will be amazed that you're not familiar with them, if you're not familiar with them, but I only discovered them somewhat recently myself, so they're definitely something us older Emacs users *can* overlook. And shouldn't. :)

You tell me, wise one! I only been using Emacs half a year. I hope you know about Org mode

Bless me ancient hacker guru! So that I may one day follow the ways

Since you use terminal windows a lot, you owe it to yourself to try out vterm.

As others have mentioned : magit, Orgmode ( do not miss out on this one ), and various LSP integrations are the big ones. I do most C, C++, and bash myself, so if you're interested in taking any of those for a spin I can post my configs. I'm very very interested in is seeing your config, because you likely know more about emacs than anyone on this board after your years of experience with it.

Thank you for thinking that! I would say instead that the key sequences are probably more deeply embedded in me than most, and I can swiftly create quite complex keyboard macros, and elisp is easy for me. I’d compare that to a 60 year old doctor who can sew a stitch like nobody’s business. BUT as clearly been shown here, there’s newer things - some decades old - I don’t know. In that I am also like an old doctor - I haven’t kept up with the newest things.

that is "just" 3 years before I was born... and I thought it has been long since I started using emacs back in 2013.... pffff

magit, man I can't work without it... such a breeze instead of lengthy git commands

if you didn't do it before, try doom emacs... has everything elegantly set and great themes, add ons, and easier management if configs inside the ~/.doom.d directory

disable evil mode for emacs shortcuts instead of vim.

Go to melpa.org, sort its packages by "DLs (Downloads)". https://melpa.org/#/?sort=downloads&asc=false

I'll say if I had to pick between knowing elisp like the back of my hand, or knowing about Orgmode and magit - I'm picking the former 😁 I think that there's probably a handful of real useful packages and features that've been added, but for most of us young guns the vast majority of packages we pick up are a stand in for routines that you probably write yourself. At least for me, as much as I love LISP and writing my own routines - I'm still not "fluent" in elisp like I am with C or bash, so I spend most of my time reading the manuals rather than implementing. I look forward to cruising without bloated packages as a crutch one day.

Back when I was in college, there was a perceived value in knowing lisp if you were interested in AI. This is no longer the case, but that coursework did give me a leg up in elisp. Also, in the 1990s, when I used Emacs in an MS-DOS window on a home PC, I was too cheap to purchase a compiler, and for 10 years, any programming I did for home or hobby was done in elisp and used Emacs as its user interface infrastructure. Eventually, and this took a while, GNU/Linux started bubbling up, I put it on cheap hardware, and used other languages for those purposes. But out of habit, I still haven’t bothered with a graphical desktop environment, and I SSH into my Linux box (now used for home automation) and create a single screen-sized ssh terminal window with Putty and start Emacs and stay in it. Hence, multiple terminal windows, multiple editing windows, etc.

While broadly it “gets pretty much the same thing done” as built-in features, you should try Vertico. It’s wildly better than the built-in completion, and has the configurability to be quite unobtrusive.

Not the OP, but i've been using Emacs since the 90s, and given that i've put lots of time and effort into getting my Emacs config just right for me - it's now basically stable - and assuming that the OP is in a similar situation, i'm not sure that Doom would provide more benefits to the OP than the costs.

I got maybe a year on you, 1979 tops20. I was miserable 1985-95 without emacs, except perfect writer. android zelm emacs is unstable, i wonder if one of the more compact, minimal versions might not be ported. I got emacs on portable apps and quantian. Wish for a java (failed w kava) version for my linpus machine

agreed! I only switched to doom recently too. I liked my config but i kept messing it up and decided to throw it away and do doom emacs 😂 (i think my mistakes are noob mistakes as well for you guys but I had to finish my PhD and hence ditched manual tinkering)

This is a fun post. I've used Emacs since the 1980s too. I did use teco briefly but I don't remember if I used emacs macros with it. If you're not using it, emacs has a GUI now ;) I assume you know emacs longstanding features like dired, calc, info, calendar, gnus, compile, shell, vc and hopefully tramp and either dabbrev or hippie-expand. As others have said Org and Magit are two big killer app packages. There are now package managers for emacs making it easy to install packages from archives. I'm happy with the builtin package.el but others use different ones (e.g., straight) There are a number of completion packages available now and they're a big improvement in lots of areas of emacs. It took me a while at first to figure out what they did, but they change the way commands read from the minibuffer. If you use ido it does this for finding files and switching buffers. Other completion frameworks do this for these commands and all others too. Builtin options include icomplete and now fido and the big 3rd party ones are helm, ivy/counsel, and vertigo/consult/embark, there are others. Basically they change how hitting TAB in the minibuffer completes, and might show a list of options in the minibuffer or in a temporary \*completions\* buffer and might order them by most recently used or alphabetically or filter them in a variety of ways to find what you're looking for (a file name, buffer name, command, function, variable, face, etc.) faster. Most will have some way to display extra info about the candidates (files sizes, buffers sizes/modes, documentation for functions, etc.). It's a big change in how you use emacs, but I like it a lot better. Particularly if you're exploring new commands/packages. Project level commands are nice. Doing find-file or switch-to-buffer and only having a list of files or buffers in the same project is nice. Doing a grep and having it look at just files in the project is very convenient. Projectile is the big 3rd party package that does this, recent emacs has a builtin project.el that does it well enough and is well integrated. Jumping to definitions of things used to be done via TAGS, now there's a builtin package xref that does the same. It "just works" for elisp and other modes use various backends (it can be TAGS or lsp or other systems) and works well. It's well integrated with other systems (project, eglot which is an lsp client, etc). LSP is the big new thing for programming languages. I think it will change a lot of emacs but at this point I'm not sure it meets your threshold of not merely being different. It's usable and if you want lots of pretty bells and whistles like other IDEs have, lsp-mode and lsp-ui will give you some. Since you've been using emacs so long, those things might not interest you. I'm using it with python but I think elpy was just as good though it's somewhat less maintained now. I like which-key for discovering commands on prefix keys, this works with all bound keys/commands. A 3rd party package hydra lets you make a special kind of keymap that pops up prettily formatted help to help you find a command. transient is a similar package which Magit uses for its interface and it is now builtin to Emacs, we'll see if more packages use it. I like building custom transients for packages I'm trying to learn. Making them helps me learn what the package does and then using them helps me remember the bindings. Emacs certainly has good builtin help and discoverability but I think these will cross a qualitative difference threshold at least for some uses. Emacs 28 added repeat-mode making repeating some commands on prefix keys easier as they only require one more key (not the whole prefix) to do it again. I've become a big fan of symbol-overlay which lets you easily highlight all occurrences of a symbol (in the buffer or just a defun) and puts a keymap on it making it easy to jump between occurrences and rename them all. wrap-region lets you easily surround the region with paired delimiters (quotes or parens, etc), it pairs well with expand-region which lets you repeat to expand the region by semantic units (symbol, sexp, defun or word, sentence, paragraph like units but more too like whole strings excluding quotes and then including quotes). grep, find-grep and rgrep are fine and still work. The newer replacements like ripgrep are a lot faster and honor .gitignore-like files and that's qualitatively better. I use rg.el as an interface to ripgrep. If you haven't used them, wdired, woccur and wgrep can be fantastically useful. Basically they let you make the regular versions of those buffers writable and then saves any changes you make back to the original files. It makes mass file renames in dired very easy (use your favorite keyboard macro). Doing a grep on a project, then doing wgrep (it can be via rg), changing all or some lines and then saving them all back to the sources is extremely satisfying. I also recommend the book Mastering Emacs. it's intermediate level stuff but a good survey of lots of different things.

Selection frameworks like helm, ivy, etc. can be possible improvements. Here's a page about Helm, for example, showing various uses with screenshot demos: https://tuhdo.github.io/helm-intro.html

You're describing me. I was born in the late 80s. Started using emacs only 10 years ago. Have been evangelizing it now for 5.

Thanks, now I no longer feel that old :-) started using Emacs 1999.

wow! so many good suggestions.

Oh, then, you'll feel right at home in exwm, the X Window Manager for Emacs (which, nobody mentioned yet, I believe). The perfect tool if you just want to just live in Emacs. I'm using it, together with eshell, and couldn't be more happier. You can manage your workspaces and windows (placement, switching), etc with elisp. What more could you ask from life?

A very nice wrap up, indeed!

I've heard one guy say 'magit broke my branches', the only time someone had to say something about negative about it, beside that i'm still fascinated by magit.. it's a tactical laser like tool.. silent, invisible, cut through its job like butter. My colleague uses vscode git interface and loses time on useless problems.

[deleted]

Doom is not aimed at this guy. Why would you introduce all that complication for some kiddy wheels if you are already perfectly fluent.

Using emacs since about 1995. I use many suggestions found on this thread. One less well known one I like a lot is key chord mode. https://github.com/emacsorphanage/key-chord. I use it primarily for window navigation/management but may try it for other things. Also ace-jump is very handy. And smudge if you listen to Spotify.

- lexical binding - packages: foundational ones like dash, to get FP idioms (a bit shorter and cleaner than CL inspired ones IMO) - use-package: john wiegley's gift to humanity to fight init.el bike shedding - org-babel: a bit like knuth LitProg, people do tons of stuff with it; see http://howardism.org/Technical/Emacs/literate-devops.html

Thank you!

>Thank you! You're welcome!

I second this. For me Exwm+Emacs daemon+tramp is perfect

I'm learning a lot reading all these great comments. I'm relatively new to Emacs, so there are many things I need and want to learn. I've been thinking about trying (but haven't yet): 1. Avy Jump. Supposedly, it lets you jump to exact places on the screen with little effort. I don't know how useful it will be. people make it sound amazing. maybe my high expectations will let me down. `i-search` has served me well so far, but I feel there might be more waiting for me. 2. Hydras/Transients. Think to when you run a keyboard macro with `Control+x e` and to repeat it you just need to press `e` and not `Control+x e` all over again. the reason I've been holding off on hydras/transients is I don't have any good ideas on how to use them even though I can see that they're powerful. (`F4` is a better way of executing a macro, but it's just an example.) 3. Magit. I hear it's awesome, but I couldn't understand the introductory material on the main page. I found it confusing and got frustrated. I only learn by examples. 4. Org-mode. sounds useful. don't know if I need it, though. Things I use: 1. Do you know about the keyboard macro counter? `F3` begins a keyboard macro. `F3` inserts the number where the keyboard macro counter is (it begins at 1 by default \[you can of course change it\]). `F4` ends the macro. `F4` repeats the macro, and the counter will go up incrementally. 2. I recently began using MacOS and learned that it has the `super` key modifier bound to the GUI key (the windows/penguin/command key) and that, furthermore, it has its own `super` shortcuts. this has blown my mind. it's amazingly useful. it's taught me many great commands that I didn't even know were commands (I never looked). A thoughtful lad put all of these shortcuts in a gist: [https://gist.github.com/EMPAT94/691526ebe01bf74cdee479d92ec4f058](https://gist.github.com/EMPAT94/691526ebe01bf74cdee479d92ec4f058) Some that I love and use: `edit-abbrevs`, `isearch-yank-kill`, `revert-buffer`, `isearch-repeat-backward`, `isearch-repeat-forward`, `ns-copy-including-secondary` (Darwin BSD-specific, but it can be ported, I suppose), and `ns-paste-secondary`. 3. last but least, homerow mods. I put modifiers on my homerow with dual-function keys. for example, I tap `a`; it sends an `a`. I hold `a`; it sends shift. Emacs is very comfortable to use for me. Chording is a pleasure. this is not related to Emacs directly, but I wanted to mention it anyway.

magit

GccEmacs is a HUGE improvement imo

TBH, I'm now scared to try magit =) I've been working with git my whole career partially by just CLI, partially in IDEA. And the latter has some things that makes things much easier and safer. I'm talking about comparing revisions, picking up parts of the diff, resolve conflicts. Can magit do all that as well? I'm intrigued but mostly afraid to be disappointed at this point.

Trivially, yes. But so can the builtin VC interface in Emacs. For simple one-offs like diffing your buffer against the base revision you can use `C-x v =` which is my preferred tool for that. (I do use Magit extensively for most other things.)

> Mastering Emacs It's a wonderful book. The main thing I personally got from the book was an excellent overview of **how** to use the built-in introspection and help system. It was a game changer. Not just because you can find help when you need it (obviously) but seeing how exploratory emacs is compared to anything else was a absolute revelation. The closest I've seen is Smalltalk. I finally understood why people praise Smalltalk so much when I took the [Pharo MOOC](https://www.fun-mooc.fr/en/courses/live-object-programming-pharo/) a while back. It was a real eye-opener and I feel like emacs and Smalltalk share the same spirit, just based on on different languages. It makes me wonder what it must have been like to use those lisp machines back in the history of computing.

More then once I just showed die hard vim users just a short 5 minute demo of org-mode, and few weeks later I got a message like "hey, I now ditched vim for emacs, any other cool stuff you'd recommend?" For magit I had the advantage of working in the Maemo/MeeGo team at Nokia back when Marius was working on magit and working in the same project, and quite a few there were using it, so I eventually also gave it a try, and stuck with it.

By picking up parts you mean selecting lines to make atomic commits ? If so yes, and magit made it so transparent that you did it without thinking about it. I think it was even before git added options for that. I'll try idea to see how things evolved but every 2-3 years i try IDEs and I'm mostly pained by their UX.

Yeah, fair enough. i didn't have access to distros / starter kits / packages / etc. when i was starting with Emacs, so i *had* to learn how to fix various issues that got in the way of my productivity. But that now means that, for example, installing `use-package` and converting the 2000+ lines of ELisp[a] in my config to make use of it seems unlikely to sufficient benefits to outweigh the costs (even though i really like the idea of `use-package` otherwise). [a] My config file is literally around 3800 lines long, but that's including white space, headings, comment lines, etc. - the "2000+" figure refers to actual lines of ELisp.

I'm in a similar boat -- been using emacs more than 20 years, never bothered with org-mode or magit until recently. No need for org because I was happy doing everything in plain text and LaTeX, magit because I was perfectly happy with the command line. Finally making the switch to both in the last couple of years, just out of curiosity at first, and they are both well worth it, *big* productivity boosts.

> i try IDEs Have you tried JetBrains IntelliJ IDEA (or its builds for other languages - e.g. WebStorm, PySharp) as well?

Teco was my first editor. That was 1971 on the original PDP-11, before DEC introduced the slash and model number. It later got re-branded as the PDP-11/20. I first encountered Emacs at DEC on Vax/VMS. That was the early '80s. It was a curiosity. We were not allowed to use it during the day because we timeshared Vax-11/780s. Two or three Emacs sessions brought a Vax, shared by twenty or so developers, to its knees. Our screen editor was EDT. I got started with Emacs for real at Apollo Computer in the latter '80s. There I collaborated with Leonard Zubkoff to add hardware support for Lucid Lisp into the DN10K instruction set (US patent 5045992). If I recall my history correctly Lucid Emacs became XEmacs. These days I work on compilers in C++. Hacking on the Emacs C source is a true time warp. It still contains uses of the register declaration.

There's so much you can do with org mode? What bits do you choose to fit into your 5-minute demo?

I would pay for mastering emax if I could get a hard copy that looks like the version he shows off on the website

Multiple times. It's a very famous one (for good reasons). I left not impressed at the time as it has a gui first approach, while magit blends with the usual emacs transient buffer, it's light and fast.

Start pressing `prev` :) https://git.savannah.gnu.org/cgit/emacs.git/log/?ofs=156500

Depends on the person. One common demo for people also using LaTeX would be showing how I do invoicing in org-mode with cross referenced tables with the whole thing exported to g-brief via my custom ox-g-brief exporter. Beats having LaTeX (integer math...) do the calculations during PDF generation as I used to have by a wide margin.

Emacs user since around 1982 myself. Wrote my undergrad thesis using it. Still spend most of my time in emacs, though I could never get into using it for email. I still spend (way too much) time customizing & keeping up with recent developments. Best "recent" features/packages IMHO: magit, org-mode, LSP, and the modern completion frameworks (vertico etc.) C++ in LSP is great but does need some external setup, such as a compilation db to set up compiler options. LSP is killer for scripting languages. Magit needs no introduction - best-in-class git front end. Org-mode is "old" now but (a) literate programming is fun and (b) org is straight-up a great outliner.

leonard zubkoff! creator of the Concept-LNZ terminal! he burned a ROM for the terminal that understood a compression protocol for better tty bandwidth. kids today would never understand that problem :-). he was a cool guy.

i feel like andrea corallo deserves to win some emacs lifetime achievement award for gccemacs. it is just \*brilliant\*.

If you are interested in still being a Lisper, Emacs+[SLIME](https://github.com/slime/slime)+SBCL/other Common Lisp implementation is pretty nice; they have at least an approximation of CLIM presentations.

I like the idea of git outside of CLI but SourceTree is so much more intuitive than magit...

>vterm Indeed. Essential package. This allowed me to move a large chunk of my non-emacs workflow into emacs.

Yup! Leonard was a very cool guy. Very bright, enthusiastic and fun to work with. He taught me a lot about how production Lisp is (was?) implemented. He was a big fan of [Apollo's technologies](http://www.bitsavers.org/pdf/apollo/AEGIS_Internals_and_Data_Structures_Jan86.pdf). And yes, it is amazing what some simple compression can accomplish. I added very simple vertical column compression, within the limited, remaining resources of Netezza's FPGA-based scanner for its row-oriiented, on-disk table format ([US patent 9195695B2](https://patents.google.com/patent/US9195695B2/en?q=vertical+compression&inventor=john+yates)). The net effect was a 2x to 4x scan improvement pretty much across the board. It was a delivered via a software release and customers loved it.

try almost two decades later :)

order of magnitude improvement.

Within the ecosystem, org-mode for me. Outside of it, electronic calendar systems like Google Calendar or even that Thunderbird Lightning extension -- I've never found an Emacs equivalent to getting hour/minute-based and day-based reminders with alerts that recur, that stand out, etc. Daily email / email-based alerts are also useful for me.

Interesting. Never even heard of dash.

Interesting. I thought keybindings in emacs was generally called key chords.

If you try vertico, might as well see if some combination of orderless, embark, marginalia, and consult are interesting to you. Personally, once I got the knack for it, I've found myself really enjoying embark. It helps me get what I want done work less thinking. Its essentially a very well done universal dwim tool.

I love reading first-hand stories of computing history. Thanks for sharing!

Dash is a dependency for quite a few modern Emacs packages. It has list functions that are more similar to what you would find from a modern functional programming languages like Haskell, OCaml, or F#, for example `-map`, `-mapcat`, `-reduce`, `-zip-with`, `-iterate`, and `-partition`.

not all heroes wear capes.

Don't be scared. > I've been working with git my whole career Wow, how to make me feel really old. git is a recent development in my world ;). Though DVC is not new - been using that since the 90s. I've only once (recently, here) encountered someone saying magit messed them up. It's literally just a convenient and friendly way to call through to git commands. Magit (and default vc) does all the things you mention *very* well, though there are a few bits and pieces around resolving conflicts that seemed non-obvious to me for a bit - but definitely not worse than CLI git. But I feel like there's good scope for it to be clearer, so presumably some tools do so.

I used emacs on an Apollo. At first it only ran in a terminal, but Zubkoff had some patches to make it use GPR so it would run natively in a DM pad. The DM editor was great for simple editing, but not programmable.

Yeah, LSP is huge - so much more depth of code and compilation-aware smarts makes the job so much easier. The downside is the resource usage. I've been having to work on a C++ & Python & Typescript project - between running 3 language servers and a browser with dev tools open, I'm swapping hard with 16 gig of memory. I stupidly decided that was enough on my laptop, because historically I never came close to needing more unless I had to have a bunch of VMs.

Can you elaborate on why? The wiki states “Compiling EmacsLisp to native code”. What is “native code” in this case? Like machine code? So emacs with simply be faster?

There is a magit extension for vscode.

oh i forgot about edamagit

LOL ... Emacs since the late 70's (on Multics, and Dec-10's) ... I build bleeding edge master from git every few weeks, and will say gccemacs is really an improvement. Organizing your .emacs with org-babel is great, SLIME is wonderful (yet to try Sly), and Melpa ... don't forget Melpa.

Yeah it basically (as I understand it) uses gcc-jit shared library to compile code to machine code at runtime, so as a result emacs is much much faster. I think it can be a magnitude of 200-300% faster. Try it, it takes some time to compile all of the packages but it's worth it. For example the start time of the emacs daemon went from 1.5 seconds to 0.5 seconds for me

Really well written summary here. I'm not quite old enough to have been using Emacs as long as y'all, but I have been using Emacs for over 2/3 of my life. :) I'll plug vertico/consult/embark here: they are such nice, clean packages that make working in Emacs so much better. I made a newbie setup the other day for a friend of mine, and these were the first packages that I included.

(The author of Apollo's DM was another Hamilton: Jim :-) I loved the DM. I still dream of implementing the notion of an input pad and a transcript pad in Emacs. Jim left extensive [implementation notes here](http://www.bitsavers.org/pdf/apollo/AEGIS_Overview_1985.pdf), starting on page 417.

Interesting. I do like those functions...

Vertico looks interesting! What features make it wildly better than the built-in `vertical-fido-mode`? It seems similar to me, especially with `completions-detailed` set to `t`, but I'm sure I'm missing something.

I first used Emacs on a C100 terminal connected to a VAX 11/780 where it was the editor recommended to us for the computer architecture class. While I seldom use emacs in terminal mode, it's astonishing to me how little the baseline user experience (buffers, regions, point and fundamental navigation) has changed in 35 years.

The multiform extension, which allows tweaking completion behavior and appearance by context. I’m very particular about what I want completion to do in specific situations, and Vertico let me replace hundreds of lines of fragile cobbled-together pieces of Helm and Ivy hackery. **Edit:** To be fair, by “wildly better”, I meant the craptastic `*Completions*` buffer, which Vertico+Consult can completely eliminate. fido mode is a good step in the right direction, but lacks power in comparison.

Odd. Perfect writer on CP/M 2.2 is where I learned the vanilla keystrokes initially. I used that on a Kaypro II for writing Z80 assembler.

35 years? at a minimum, \*forty three\* years (1979). and it surely existed in baseline form before that.

also, C100's were \*cool\*!

OP, you only have to do two things to get into the most modern Emacs setup possible: 1. Watch all of Uncle Dave's Emacs videos on how to configure Emacs from the ground up using a literate config in Org Mode: [https://www.youtube.com/playlist?list=PLX2044Ew-UVVv31a0-Qn3dA6Sd\_-NyA1n](https://www.youtube.com/playlist?list=PLX2044Ew-UVVv31a0-Qn3dA6Sd_-NyA1n) 2. Watch all of Rainer Konig's Emacs Org Mode videos to learn about Org Mode: [https://www.youtube.com/playlist?list=PLVtKhBrRV\_ZkPnBtt\_TD1Cs9PJlU0IIdE](https://www.youtube.com/playlist?list=PLVtKhBrRV_ZkPnBtt_TD1Cs9PJlU0IIdE) Past that, its all just looking up people's configs on GitHub and copying and pasting what you like. That's how to save time and gain more efficiency these days instead of having to read the manual. Just 'do it'.

I want to thank everyone for these informative and courteous replies! I’ve already rebuilt gcc and emacs to support gccemacs, and Comparing them side to side, gccemacs is indeed faster. I’m now exploring LSP and have Org and vterm on my todo list. Then the list continues :)

Thinking about the "git my whole career" comment: * RCS/CMVC at my second company (first was an RPGIII shop and I was on the support side so I have no idea what they used) * **nothing** at my third company (the build guy had access to an SCCS tree and would build you a development environment; you gave him your edited files back when you were done). * cvs w/o pserver then pserver, followed by perforce and eventually git at the third. * 4th and 5th were/are git. Fossil or SCCS for single-file projects (archeology is fun; I also still use groff) at home.

RCS -> Teamware (Sun's DVC on top of SCCS) -> Sourcesafe -> CVS -> Perforce -> Clearcase -> Bazaar -> git -> mercurial -> git I remember we needed to be persuaded that the DVC setup could actually work, with conflict management... At the time I'd never heard the term DVC, but then when Bazaar and git came along and everyone was saying it was revolutionary, for ages I assumed I was missing something because it seemed pretty ordinary. Amazing DVC took so long to become the de-facto standard, given Sun had it so long before. Thanks goodness I never worked somewhere without source control, though I remember the shared team RCS setup had the source on some shared filesystem and we had protocols for managing shared work. Amazing we kept it together. I'm so thankful for git and magit. Things are better now.

I have used emacs in 1983. But that was Gosling emacs. Gnu emacs came around 1985.

Magit is a revelation as it makes git usable (example: I knew you could stage and commit individual chunks of changes in a file but understanding how to do it with the CLI is miserable while magit makes it simple). That said, even without magit, emacs' simpler vc-mode is terrific as it works consistently with numerous source control systems. RE: shared filesystems. The reason we switched from cvs w/o pserver to cvs with pserver is that a developer blew away the entire source tree by just removing the directory in the NFS mount. He ended up buying pizza for about eighty people and the CM person restored everything and converted everyone to pserver.

I can't believe no-one has mentioned [elfeed](https://github.com/skeeto/elfeed) \+ [elfeed-dashboard](https://github.com/Manoj321/elfeed-dashboard) makes an awesome RSS reader. I used it to find this post through the reddit RSS post. But I can scan all the RSS things and read through them far more rapidly than visiting each idiosyncratic web page. FWIW, emacs user since mid-80's.

Hi Other Oldies, I got my first emacs on Pr1me Computer (about 1982), it was big and I never configured it, later I had it on Pr1me Computer unix on 386. ever since I've loaded emacs on every computer I could, and today it's an iMAC 24" with M1 silicon and heavy configured. mvh Niels Søndergaard