This is how computing should feel

It's not surprising most of us find ourselves doing more and more in Emacs as time goes on. Here's an environment that's completely malleable and transparent - a productive playground where workflow and tooling grow organically together, intertwined. I sometimes feel like a blacksmith or the 'primitive technology' youtuber: building tools that make new tools possible, each more powerful and precise than the last, working in concert to open new possibilities. As I think about that comparison, it strikes me that this must be the key to Emacs' allure. Most of our computing tools are delivered to us on a plate, like a modern mass-manufactured product. Impressively engineered and convenient to be sure, but closed and impersonal. In a funny way, I feel Emacs puts us in touch with a much deeper human tradition: moulding and shaping our environment to suit our own needs, instead of being moulded and shaped ourselves.

Amen

[deleted]

Well this is the post that finally got me to try out emacs lol

My main machine is running Guix with EXWM, and while it's not perfect, I feel so much of the excitement and wonder that I did as a kid. I think this is exactly what you can call a bicycle for the mind.

I wish I'd discovered emacs 10 years ago. Would have saved so much money and time. All those Legos, when what I was looking for was Free Software all along.

Couldn't agree more, for me when I discovered Emacs I really could not sleep, and had to know all those packages and try them and then had to learn Elisp, I stayed awake for a whole three days and called on sick from work during my journey :P. And I am still learning, I am nowhere near professional, in a matter of fact I still struggle with some stuff and some configuration, but this is the fun this where my dopamine is released, being faced with a problem and then figuring it out. >Personally, I feel inspired whenever I open Emacs. Like a craftsman entering his workshop, I feel a realm of possibility open before me. I feel the comfort of an environment that has evolved over time to fit me perfectly – an assortment of packages and keybindings which help me bring ideas to life day after day. > >Daniel Higginbotham - [Clojure for the brave and true](https://www.braveclojure.com/basic-emacs/) God damn, I love this community.

This is beautifully written. I like to say that Emacs is personal computing, in the *personal* sense of that word. It think it's a shame how mainstream computing is becoming increasingly "siloed", with data hosted by others and often manipulatable only in the ways made possible by the services hosting it. If you're lucky, two mainstream services you want to combine might have a few "integrations", but that's a tiny little box to live in.

Well, yeah, right. However: What you just described isnt a charachteristic of solely emacs but of bottom up development and high level lisp programming. People could even do that kind of development in javascript. But they don't. Neither the tradition nor the culture of organical sw development is present in js land

> This is how computing should feel Personal computing for fun - probably, but businesses require things to be done fast, not playing Legos. And that's where Emacs shines for me: - A universal and consistent (well, mostly) UI to all (with minor exceptions) text information in the system, whether it's a directory listing, code, shell commands, or instant messages. - Discoverability. You have help/`M-x describe`/sources/`which-key` at your fingertips, no need to read the full documentation, googling etc. It saves time a lot. - Lisp. Far from being the best one out there, but still a decent one. - Ecosystem. Sure, VS Code has more plugins already, but it's still pretty large.

It's a good post.

[deleted]

That's the fully-introspectable, dynamic approach of Lisp machines, which Emacs inherits from and emulates. https://en.wikipedia.org/wiki/Lisp_machine The one OS that I'm aware embodies this approach to computing is Symbolics' Genera. https://en.wikipedia.org/wiki/Genera_(operating_system) Watching a demo of it will make you wanna cry. In parts, it's way more advanced than anything available to the general public. https://www.youtube.com/watch?v=o4-YnLpLgtk https://www.youtube.com/watch?v=7RNbIEJvjUA&ab_channel=media.ccc.de Instead, we got UNIX, where passing bytes between opaque binaries is the best you can do. Pretty weak in comparison.

I love everything about this post. You hit the nail on the head for me with how I relate to using Emacs. Machinists fashion their own tools to solve their problems, much like the experienced Emacs user will write their own function, mode or macro to suit their needs. It's always been my opinion that no Emacs config should be the same. I've built and rebuilt my config several times and am always learning something new, as a user since 1999.

I feel the same way! Have been using Emacs since January and really need to learn elisp. Apart from the beginners and reference manuals does anyone have other resource recommendations?

The best thing about emacs is that you can implement any feature you want. The worst thing about emacs is that you *have* to implement any feature you want. But in the end... A Jedi must build their own light saber.

This is exactly what I was thinking about differences with other editors. I have my own workflow, my own functions that do very specific things. The used functions (APIs) could be mixture of unrelated things, yet somehow it works.

There is nothing inherently special about Emacs in this circumstance. I know at least one person who has a hand crafted desktop (libraries included) that does not include a drop of Emacs and is far more impressive than most Emacs setups I have seen. An Emacs user isn't all that special, he/she is more "obscure." [ In fact, I see Emacs users limit themselves to the popular tool for the job rather than explore something completely new, *cough* org *cough*. I found a far more interesting Zettelkasten setup where each note was a directory containing the metadata, including backlinks, in one file, the note itself in another, while the "attachment" was simply just another file in the subdirectory. ]

Emacs and FOSS are like legos with infinite pieces, and creator, technic, and mindstorms sets. Macs are overpriced new legos with fancy bespoke pieces everywhere that can't be repurposed. Windows is Duplo.

That's just what desktop computing means. Something forgotten since Xerox/Symbolics time that try to came back but cyclically fails due to lack of interests and curiosity by most and education in general...

Yes for Guix! I just went back to StumpWM from XMonad and it was so refreshing to be back in my favorite language and be able to tweak so easily. XMonad is great, but I have little Haskell knowledge and find Lisps more fun. So now I have my almost-Lisp Machine: Guile Scheme for the distro and system configuration, Emacs Lisp for just about everything else.

I was about to switch to Xmonad, but I have used StumpWM very briefly in the past and was very intrigued by it. Would you mind talking about your experience using StumpWM and Emacs? I typically follow System Crafters for this sort of thing, but Dave hasn't had good experiences with Stump in the past so he doesn't cover it. Maybe even post it over on /r/stumpwm if you have a lot to say about it...

Emacs is not the ideal computing environment, but it is closer to the ideals of that computing environment than anything else existing today. It is unified, comprehensible, and plastic -- you can do everything you want to, you can understand it and explore it (down to a certain point), and you can modify it to behave the way *yous* want. It's not *good* but it is the best thing available today.

Well that's hardly true is it.

100%! Every once in a while I can't help but nerd out about just how *compelling* emacs is. Like it has more issues and frustrations than I can count, but there's just something moreso to it than any other computing environment I'm aware of. One of my big life goals is bringing the emacs model to more software and more people -- I'm currently writing a Wayland compositor that embeds Guile scheme and one of my long-term projects is a lisp meant for embedding with powerful editor integration in the same vein as elisp.

Windows is Playmobil

I must say that using Emacs definitely changed my perspective on computing. I used to agree pretty strongly with "1 tool 1 job" until I started needing a growing variety of tools over the years. Pipes and redirections are powerful enough for most of those tools to interact with each other but having to constantly switch context and usage paradigms gets tiring really fast the more tools you have to use. When I dove into learning Emacs, I got to really have a glimpse at how a truely integrated environment could look like and it just makes sense to me. Software should serve the user and make their life easier. We already understand how a customized experience can be powerful and Emacs provides that and more. It does it in a consistent and well integrated manner most of the time; and even when it doesn't, it is easy to tweak and modify it for our specific needs. Having a tool that evolves with you is an effort and investment but is extremely rewarding on the long run. I wouldn't say Emacs is perfect but its approach and vision of what the perfect computing environment could be is something I wish would get more attention.

A diamond is very pretty. But it is very hard to add to a diamond. A ball of mud is not so pretty. But you can always add more mud to a ball of mud. -- Joel Moses and/or Paul Penfield

Amen

capitalism should trade money for shared excitement

i've seen vscode and i'll take emacs fun.. emacs fun is fast, and solid.. vscode slows you down often and locks you in

Well, that's inspiring. But I'm still in the "oh this is a pointy rock" phase.

I do have to admit that in some ways VS Code feels like a spiritual successor to Emacs but built on technologies that more modern developers are familiar with. The web stack is easier to hack on for most people these days. And emacs lisp is... special, lol. I haven't tried to customize VS Code much myself (I feel like Emacs just fundamentally works differently so it's hard for me to use any other editor) but at least VS Code does seem to have a lot of hackability. E.g. there's actually a pretty good magit clone. I still use emacs, but at the end of the day I sadly have little time for hacking on my config and there's a lot of neat functionality in newer editors. The universal interface in Emacs is great but it does make certain interfaces harder to build.

Well, for me the fast part "for business" is there, surely it takes time to get there and that's can be compared to school time, but thereafter: my taxes? Anything is a key (org-roam-node-find) away, anything organized in org-mode, files org-attached, mails linked (notmuch), notes, ... anything is quickly searchable and it can even be queried a bit (org-ql). In "modern software" terms I would need a giant business software suite to achieve and inferior result. And that's not only for taxes but for essentially all I do on a computer. Witch means: once you have learnt and craft your system you are FAR faster and in comfort than anything else. Or trade initial CapEx vs recurrent OpEx. The real business issue happen at software-house level: if you give "computing power" to the masses you'll make far less money with crap than today model allow. In a world or real desktop environments, with modern storage and connectivity who want crappy web 2.x services and relevant ads? How surveillance capitalism can exists? You can't even easily publish news following users preferences because news are consumed via feeds, no click counting, likes, +/-1 etc to help. It would be a world of QUALITY things, and making money on quality is hard.

VS Code is a "spiritual successors"? Well... IMVHO if you think so you do not know Emacs at all. Can I have my files managed effectively by VS Code? In Emacs via org-attach yes. My code to do so is essentially ZERO. In VS Code how many SLoC I have to write to achieve something similar? Mails? Setting up fetchmail+maildrop+notmuch is relatively long because very few works on them, but it's still few SLoC, in VS Code? How about my notes where I concentrate essentially ALL my digital life? How about managing my desktop (EXWM)? VS Code IMO is a crappy text editor with some extra features at a hyper-big price (Electron), Emacs is a desktop operating environment. It's like comparing a washing machine to a home: a home also have a washing machine but you can't compare them.

That's because IBM know how to make money giving breadcrumbs of tech to the masses keeping the real tech under their control. Classic desktop model (Xerox/Symbolics) on contrary give the power away.

Emacs indeed has very good habitability. More on that: http://akkartik.name/post/habitability

Unfair to Playmobil!

Guile Emacs?

Culturally vscode is nothing like emacs, it's hackable and you can leverage dom/js to do nice stuff but the result just isn't there (plus it has very weird UX behavior, or bug i don't know). Honestly it's a pain to witness..

I feel the same with Linux philosophy and vi! It’s amazing

Yes. A Lisp machine. Lisp made particularly useful with text. (Or text made useful with Lisp.) Unix at least exploited the character-stream (pipes) thing. Emacs lets you and Lisp do more using text. It's Lisp with buffers (esp. text buffers) and windows. And yes, Lisp machines had Emacs. Emacs was a big part of a Lisp machine as a human-computer thingie.

Emacs is nearly perfectly imperfect. You can't improve on perfect. Emacs is about perfecting, sans fin; it's not about perfect.

This one helps you get all the practical elisp to be self-competent and have fun in the shortest time. http://xahlee.info/emacs/emacs/elisp_basics.html

Haha, I agree with this statement but I meant that it isn't perfect in the way it provides the means for "perfecting".

Yes and no. Does your JavaScript environment have buffers and windows and ... - with every action you carry out being programmable as a function? Lisp alone doesn't have buffers and windows. It has strings and files and... Emacs is Lisp with interactive text.

>I'm currently writing a Wayland compositor that embeds Guile scheme You can't just say this and not drop a link!

There was a time I loved Linux, and in my heart I still do. But that sweet Apple Silicon is sooo good.

I used to love customizing Linux and trying new packages. Now I don’t care as long as I’m in emacs.

never noticed how much emacs sounds like a psychedelic out of context

I think this is the most hilarious description of true evil that I've ever heard

I stopped using Stump a few years ago to learn a little Haskell and because of some bugs with Stump. Coming back now I see many of the little bugs I hit are gone (more stable, less weirdness), though the main one was around multiple displays that I'm not sure has been fixed. Seems there were finally some commits recently that should address it. I rarely use multiple displays, so it wasn't a big deal, but was just part of wanting to try something new after dealing with some instability. Though being able to debug with slime is just great. XMonad was perfectly stable, lots of users out there for configs or tips, but it wasn't the playground for me that Stump and CL are. If you like Haskell more (not that I don't, just don't know much) or find some features better there (tends to layouts and automatic tiling, Stump more manual but also has "dynamic" tiling now too) you may like it more. It is a great WM; I just enjoy Lisps more. I should say, in case it wasn't clear, that Stump is in Common Lisp, not Emacs Lisp. Though, honestly, I mostly know CL and that gets me by just fine for both Emacs and Guix (Guile). Anyway, give it a try! There's friction in some of the tooling depending on your distro for either (e.g. Haskell on Arch is not nice to deal with packaging, I went with straight Cabal/Stack; for Stump you may prefer git versions as they typically don't put out releases often, if that is easy on your distro). The designs are a bit different but I got to a similar place with both pretty quickly. To me, it came down to the language and how you build up your WM of choice, since both really are more libraries to make what you want. I just wish we'd have something as nice in Wayland for when the time comes (no, haven't tried Sway, but I want a Lisp-y WM). In case it helps, you can see my configs for both in my dot files: https://github.com/podiki/dot.me I recently did a lot with my Stump config as I was energized by returning to it, doing things I didn't realize I could do before. It does need cleaning up now.

Just to give an extra data point: I think that XMonad and Emacs play perfectly together! It's possible to very painlessly [call Emacs from XMonad](https://tony-zorman.com/posts/2022-05-25-calling-emacs-from-xmonad.html) to write what's essentially tiny elisp scripts straight within your config. Indeed, there even is [XMonad.Prompt.OrgMode](https://xmonad.github.io/xmonad-docs/xmonad-contrib/XMonad-Prompt-OrgMode.html) for quickly capturing TODOs and putting them into your main org file (blog post about that module coming soon :) I agree with the other commenter that it heavily comes down to which language you prefer day-to-day, as well as which core design decisions you can most easily align yourself with.

This is how mud should feel

This is great, thanks for the write-up. I'll definitely check out your files. Aside from the main documentation, do you have any recommended resources for StumpWM?

Very cool, I'll check that out. Thank you.

Welcome! Reading the manual and the code itself are the only tips I have. You can find some people's configs on GitHub and the like too by searching. Note that the manual on the website is very out of date, so use a local version after installing: https://github.com/stumpwm/stumpwm/issues/944

This guy--he gets it.

It's definitely not ready for any use yet, but the current code can be found here: [https://github.com/lambdadog/winter](https://github.com/lambdadog/winter) 0.1 is intended to implement a tiling WM so I can begin dogfooding as early as possible but eventually I'd really like to develop it out into something akin to a monolithic desktop environment like plasma or KDE, just all implemented in lisp. The big barrier is of course graphics (implementing window decorations and bars and such in a way I'd be happy with -- ideally I'd just want a simplistic framework to do so from guile, but that requires I actually write my own usable graphics framework)

> (blog post about that module coming soon :) [and it's done](https://tony-zorman.com/posts/orgmode-prompt/2022-08-27-xmonad-and-org-mode.html)! (Probably not worth a top post on /r/emacs, since it's almost entirely about Xmonad itself).

>I think this is exactly what you can call a bicycle for the mind. I agree. Mr Jobs made the world believe his GUIs are a *bicycle for the mind* while he actually created a *subway system for the mind*. No custom destinations, no shortcuts, no agency whatsoever. Easier to use at first, but at a high price in the long run. I would argue he and Mr Gates did to personal computing what McDonalds and KFC did to personal nutrition.

Have you looked at StumpWM? There may be code there that inspires you.

Yes, but there's a little bit more. Most (though notably not all) Emacs users write software for a living. And most of that software is designed by and intended for _other people_. Emacs gives the programmer a chance to make something exclusively for personal use, without giving a single damn about anyone else's needs, wants, or specifications.

I've played around with StumpWM some, but there are several barriers to really porting over its models: - The differences between X11 and Wayland - That StumpWM is written 100% in a high-level lisp (Common Lisp) with X11 bindings rather than a core being written in C/C++/an adjacent language that embeds a lisp + It's worth noting that this is much harder to do with Wayland than X11 as well as you have to handle all of the lower-level details that the X server itself does rather than just the window management. - A rather drastic difference in the actual final vision I have and what StumpWM is doing.

in js you have events in a single threaded environment. JS started it's existence as being a scheme. You can catch every keypress in the browser with js, so it is really comparable in power to an emacs(if not the prettier lisp syntax of the language). I won't comment here on particular data structures like buffers and windows, it really doesn't that matter whether you eat apples or oranges.