Life is 90% of my use cases for org-mode

> emacs outshines all other editing software in approximately the same way that the noonday sun does the stars

What makes Emacs genuinely great? Not that it was built a long time ago and withstood the test of time. Not the fact that it is absolutely free to use, distribute and extend. Not that it doesn't have tons of bugs (it does), or has superb support for every known programming language (it does not).

To understand what makes Emacs so awesome, to learn and master it, one simply needs to embrace the single fundamental truth about it. Emacs based on Lisp. And please don't make a mistake - I am not talking here about a programming language. I am talking about an idea - one of the most magnificent ideas in computer science. Embrace the awesomeness of that idea, the fluidity, and malleability of the structure. Accept it with all its incredible power and some unavoidable flaws - and you will gain superpowers. Which is not necessarily a good thing. Let me explain.

There's a scientific term "umwelt" that biologists use to describe the world as experienced by a particular organism. Every one of us has this "umwelt" - our "subjective view of the world." Our umwelt is limited by our physical and mental capabilities, past experiences, and social circles we grow up and live. e.g., your subjective understanding of Renaissance Art would drastically differ from when you're taken to a museum at the age of three, and when you go there as an adult, or after studying art for fifteen years.

Learning and understanding Lisp expands your umwelt. You will start seeing things differently. It doesn't inevitably make you a better programmer; it might, but doesn't guarantee it, just like suddenly gaining the ability to see things in the infrared spectrum not guaranteed to make your life better.

Finally, once you embrace the idea of Lisp, soon enough, you find out - humans have yet to invent a better Lisp environment than Emacs.

And that's what Emacs is - it is not just an editor, it is not a mere IDE. Most importantly, it is a Lisp environment - living, "breathing", dynamic and malleable. That's what makes it so extensible. And that's what makes it so versatile. And that's why it will never die.

Oh no. They say you shouldn't meet your heroes, but now I think it might be just as important to never learn which editor they use.

I wish someone did a thorough comparison of emacs with the newer extensible editors, such as Sublime. Is there something substantial that Sublime users are missing?

thanks!

This is too peak HN for me.

If you use eww in Emacs, the readability of that post would be exactly as you wanted it to be, given that you've spent enough time configuring and tweaking your Emacs theme. Emacs (in general) is not for everyone - but it can be that perfect tool, that is truly perfect just for you.

It'd be hard to argue that it ISN'T "readable." Maybe some would think it's ugly (I don't), but objectively speaking it's ticking every "readability" box.

Honestly at this point it is usually easier for me to read the raw org-mode source file in an emacs buffer than to wade through whatever random web rendering and author has picked when they export to html.

A single circle, are you saying?

For want of a margin the kingdom was lost.

I hate no margins and use the Goyo vim plugin to make my editing experience more pleasurable.

There must be an package where you can give url and emacs will display the article in org-mode format. Even better would be a package for reading hacker-news, surely there must be one.

EDIT: In fact there is a package called hackernews. You can open links inside emacs using text-based browser. No readability issues there.

It would logically most likely be two circles intersecting, as Venn diagrams don't usually make a statement about the sizes of the sets.

The template seems designed for mobile. It looks pretty good on my phone but worse on my laptop

Emacs is great, but use whatever you want. Of course you’ll be missing on something but that’s true for a lot of things.

I think the appeal is hack-ability. You can easily write a little Lisp program that hooks into emacs which you can trigger any number of ways.

I say this as an avid emacs user: Emacs has a real problem in that it's very powerful but the, let's say, spiritual leader of the project (Stallman) is so wildly divorced from the real world because of his personal choices that he really has no idea what makes a compelling UX vs what makes a complete mess of arcane incantations. On top of that, the documentation is only suitable as a reference for someone who already knows emacs, so it's hard to learn.

To wit: Again I really really like Emacs as a piece of software, and I've been using it for like 10 years now. Maybe 3 or 4 of those years I've been using it reasonably seriously and even I find my eyes glaze over because of how dense and unapproachable the documentation is.

On top of that, being a political project, Stallman actively resists certain improvements to Emacs that would for example make it work better on my Mac, because my Mac is nonfree and Stallman would rather have an objectively poorer piece of software than one that "encourages" using MacOS.

And of course the other senior people in the Emacs project don't want to go against Stallman, so emacs is doomed to being a mediocre niche text editor with unrealized potential to become a household name.

If someone wrote an open source clone of Emacs that adopted some sane defaults, modern UI conventions, and dropped all the political BS it could be so much better.

Alas I don't have the skill nor the time to attempt such a thing.

Edit: hey how about a substantive reply rather than drive-by downvotes?

Just sit down and follow the tutorial that you can click in the emacs homescreen.

It is not that easy, but the effort you invest in learning emacs will pay off eventually.

Emacs is just a different universe. You either learn to live in it or you don’t. That’s all there is to it.

I only really use emacs for Org mode and Org mode extensions. It wasn't too hard to learn just enough emacs for that. The motivation comes from how fast and convenient org mode is as a journal and a static site generator, compared to other tools, and having all my documents in plain text for future proofing.

Emacs is an enormous investment but every time I'm forced to use another editor or IDE I'm reminded how much it pays off. Fundamentally, all Emacs does is treat the whole world as text. Everything from that point forward is about giving you (or allowing you to build) tools to manipulate text in a way that is natural and powerful for you.

This doesn't sound particularly earth-shaking, but it really is. Think of a language like Ruby or especially Clojure, where there are a few core data structures, but many things that leverage them. This means that every time you learn part of the Ruby Array API, or a useful function to work on Clojure sequences, you get to use that _everywhere_. So all of Emacs' basic interactions (and they may seem weird to begin with but they're honestly just trying to save your wrists some pain) work everywhere. You can always trust your intuitive, spatial model of the thing you're looking at. Search backwards in a text file, find some text, select it, copy it, go back to the end and paste it. That works exactly the same in a shell. It works exactly the same in a database client. Or SSH'd into a server. Or replying to an email. Same gestures when entering commands, same gestures moving around in autocomplete popups.

Everything you learn with Emacs (and later, everything you write with elisp), has a little incremental benefit to your power and productivity manipulating text. Except everything is text, and so it all multiplies together.

For whatever reason, I've been trying VSCode on Windows the last couple of weeks, coming from an Emacs on Linux background. I cannot tell you how painful I find it, even after making a pretty good attempt to map all the keys correctly (snarky sidebar, sorry: every editor and IDE has really good Vim key bindings, but terrible Emacs support. I used to feel bad about this until I realised it was a sign that Vim people clearly didn't use Vim that much, whereas Emacs people never leave Emacs). But VSCode begins at a completely different level of abstraction to Emacs. It doesn't want to show you a text-based UI everywhere, and implement tools to manipulate text. It wants to show you windows and panels and configuration screens and extensions with their own behaviour. Everything is modal and different, some windows are special, and you can't just navigate around the same way everywhere.

So, sure, this isn't for everyone, but it's what I love about Emacs, to the point that the many regular indignities it forces on you (hangs if you're not careful about large files, abysmal performance of various things on Windows because of the overhead of starting processes, and sure, the learning curve for some people) are bearable because everything is so natural.

I have been using zim wiki. Its essentially just a basic text editor but it has a tree view for your files and supports basic syntax including check lists. I have found this suits basically all of my needs.

Checkout the emacs wiki: https://www.emacswiki.org/

See if you find any features or extensions that aren’t available on notepad++...

My .emacs configuration is based on vim style modal shortcuts that make me faster than a mutant: https://github.com/tinku99/dotfiles/blob/master/init-public....

I also use org-mode as a minor mode for autohotkey code editing, by changing the outline character from * to ; ... https://github.com/tinku99/ahk-org-mode

Longtime (two-decade-ish) previous emacs user. I lived in it. I used it for literally everything - web browsing, mail, mp3 playing, etc.

> I am afraid I'm missing something.

You are not.

Nowadays I just use crappy little text editors for small notes and JetBrains IDEs for dev work.

An anecdote on what you might be missing. There is nothing concrete that not using org-mode would cause you to miss out on, it is rather the possibility of being able to access one of countless workflows that have been built on top of it.

When I started to use org-mode it was because I needed to generate a gant chart and I wanted a text format. I haven't used that functionality every again. Since then I have used org-mode for a variety of things, but never all at once, always a little piece at a time. Typeset a thesis in latex? Execute analysis code in a reproducible way? Write DRY bash scripts and tangle (compile) them? Run and log the output of one-off commands on remote servers so that if you ever have to do it again you have a record of it? The list goes on and on.

Last week I was told that I needed to start keeping track of the time I spend working on different tasks. Despite keeping todo lists I have never used the org clocking functions, ye there they were there, just a C-c C-x C-i and C-c C-x C-o away. Integrated into my workflow when I needed it with all of 30 seconds of effort and two key combinations of overhead.

Emacs is useful because countless others have encountered problems the likes of which a single person only rarely dreams. Not only that but they have probably already implemented a solution that is fairly easy to find once you encounter the problem and in 80% of the cases can be used unmodified.

Yes, you and all the rest of us are missing something. It is impossible NOT to miss something and no tool can solve that for you. The question to me is whether you want to spend your time learning a tool and integrating with an ecosystem where you never have the possibility of benefiting from the things that others did not miss.

Don't worry about it too much. If your workflow works for you, go nuts with it.

But should you one day find yourself needing an informational omnitool that can be adapted to the task at hand while you work with it, you will find that there is simply no substitute for Emacs. And that's the difference between an extensible text editor and Emacs. A few lines of Emacs Lisp and some Unix plumbing can get you very far -- and you can debug it in production, dynamically updating the Lisp code as you use it.

You are right if you are comfortable with your editor you're not missing a lot. I tried Emacs for a while it's nice and comfortable the moment your brain get used to the keyboard shortkeys though since it's a different word you start running everything in Emacs and it becomes your OS. Why it can be a problem is another story. Anyway I switched back to use different tools for different jobs. For taking notes and managing them I use Joplin it supports markdown, todo lists, etc. and you can even copy paste images into the editor. Lots of other features as well as sync with different backends.

I have used many popular and some esoteric editors and IDEs (some of them today would be considered forgotten). The last one was IntelliJ that I used very extensively. To the point of finding some undocumented features. I have participated in many conversations regarding plugins. I have almost started building my own. I was pleased with it. JetBrains does make an incredibly powerful IDEs. After almost seven years of using IntelliJ, I switched to Emacs.

Emacs taught me something about myself that no other editor/IDE done before. It helped me to discover my hidden predilection. I realized that I am a tinkerer. You may say: "Aren't we all? We make software because we are tinkerers..." But there are two kinds of developers: non-conformist tinkerers and consumer-tinkerers.

People who end up using Emacs are those who would choose Gentoo or Arch, first of all, because "fuck Windows" and "Ubuntu is lame", and then because they can do some crazy stuff like hijacking display brightness beyond default limits (because one time they had to stare at it, sitting on a beach). Sometimes they hook up their garage doors to a DB, so they can collect data and analyze it later. Or they build their own mechanical keyboards. Etc.

Emacs taught me to abhor repetition and mundane tasks. It taught me that anything can be automated. Even Hell and Chaos can be automated. In that case, you simply end up having an automated hell and chaos. There are so many tiny examples, like whenever I'm writing something let's say in Python, and I would like to search for a code snippet on GitHub, I would simply select a piece of code in my editor and search for it - Emacs would navigate to GitHub, pass the string and even set the language to Python. Or whenever I need to create a new branch, I don't need to think about the name, I can use the ticket number and Emacs would request the issue tracker and create a branch name based on ticket's title. Or I can create a Gist (public or private) by pressing a couple of keys. And many, many more.

I can watch anyone using their favorite IDE and whenever they do something so trivial, something they've been doing for a long time, and very often I'd think - "Oh, I know, more efficient way of doing the same thing" or "Ah, I've been doing it the same way for years, maybe it's time to improve it. I just realized that this is not efficient enough." But it's not just about efficiency - when you add a tiny bit of automation to your task, it becomes so much less frustrating.

Of course, it is possible to have the same mindset and never get into Emacs. However, Emacs offers hundreds of tiny pieces to satisfy your needs. People say: "Emacs takes a long time to learn", but in reality - it would take you longer to become a true power-tinkerer using any other ecosystem of tools.

But it is also totally okay not to be a power-tinkerer. I know many developers who don't use any fancy ways of doing things, but they are still quite impressively, very productive.

Look into Spacemacs - it addresses a lot of what you want.

It understands file extensions and automatically downloads curated sets of packages for what you're editing (no more arcane copying and pasting)

The key bindings are set up so that pressing the first part of a key chord brings up all the things the next part of the key chord could be in the mini buffer

Yeah, I firmly believe more software should be built on top of emacs to leverage its power and expressiveness behind a dicoverable interface for people who are too busy or have a life.

Sounds like the package which-key [1] might help you out. (It comes pre-configured for those who use Doom Emacs, but I was using it in my personal config for awhile.). From the about: which-key is a minor mode for Emacs that displays the key bindings following your currently entered incomplete command (a prefix) in a popup.

[1] https://github.com/justbur/emacs-which-key

I felt the same way for a long time. And then I've started doing one very simple thing. I've created tasks.org file, and whenever I find some use-case, something I don't know how to do or even not sure if that's possible - I would just add an item to that file. Then I would ask questions - on emacs.stackexchange, on r/emacs, in slack channels, in mailing-lists, etc. Slowly, I have started using other Org-mode features. I started writing my own emacs-lisp snippets. Even though I still haven't mastered Emacs, today, I share Emacs tips with my colleagues and other people. If I may suggest - don't try to "boil the ocean." Emacs is huge. Nobody truly masters every aspect of it. Just do it slowly. Start with a simple list.

Here's a starting point: https://github.com/Fuco1/clippy.el

I had exactly the same thoughts.

"Simplicity. From the creators of <<in order to create a text editor, let's create an OS first>>"

BTW, I love and hate emacs at the same time.

This is a great comment.

I have burned myself with orgmode exactly because of the deceptive simplicity. It did not pick up some important TODO items because of my slight misformatting.

I think you're confusing "simple" with "easy." You may be looking at the controls of a military helicopter for the first time - switches, knobs, buttons, joysticks, etc. and probably feel very confused. But ask any experienced pilot, "Why can't all that be replaced with a single touch-screen interface? Wouldn't that be so much friendlier and intuitive?" they'd look at you like you're out of your mind. For them, those controls are probably the most efficient interface they can imagine.

There's a strong correlation between things that are confusing for the beginners, but over time become incredibly simple to use and things that are easy to start with, but over time they become cluttered, inefficient and frustrating to use. Emacs and Org-mode are not easy to learn, but they can simplify a lot of things later.

Same ! So easy and works incredibly well across multiple devices.

Is this because you’d have to use iCloud otherwise and pay for storage? What about airdrop?

Which app? "Notes" is rather generic term so curious which app you're using

Same. Emacs is my primary code driver during the day but for most things Notes is killer. One of Apples best apps right now.

I use bear after using notes for quite awhile. Bear support Some sort of md. need to use IA writer when doing my thesis as searching is a problem.

FWIW you can set up sync to phone pretty easily, Orgzly is a org-mode client for Mobile working surprisingly well, supporting dropbox and many other backends for sync, plus both Emacs and Orgzly support pasting images. As far as I'm concerned I've set up syncthing to sync my org files between my devices.

You might like [Tot](https://tot.rocks/)

I made an org-mode viewer for iOS and Android. It can load from anything that supports the standard file access API (so Dropbox, Google Drive, etc.).

https://orgro.org

I'm afraid it's macros and elisp, but don't forget that you can write a good amount of useful elisp by recording macros and saving them in your .init file.

org-sync [0] is all that I could find when I went to look into this last week. It does not have all the functionality that I would want (e.g. comments should be begin_src markdown blocks), but could serve as a start for something more, and it might meet your needs as is.

0. https://github.com/arbox/org-sync

- Markdown is not consistent across the platforms that support it. If I wake you up at 3AM would you remember the format of links? is it parentheses first or brackets?

- Extensibility. e.g.: I got tired of manually typing description of links when I insert a link to a GitHub issue, I just wrote a tiny snippet that automatically retrieves the title of that issue.

- Literate programming. For example: I can have a python snippet that when I evaluate, results would be piped it into another snippet in SQL that retrieves data from postgress, and then I can send a http request to a remote API based on what's in DB, and then use that to build a chart. Can you do that in Markdown?

- LaTeX support. I can write some complex math formulas.

- Exporting. I can turn my Org-mode file(s) into a reveal.js presentation, into a book, or a web-blog.

- etc.

While I might have been concerned about this at one point in time, emacs and gcc are some of the most ported pieces of software in existence. That said, there have been some discussions about trying to work toward a specification for how things like org-babel should work so that other platforms can replicate the behavior inside of emacs. However, as others have stated elsewhere in the comments, once you accept emacs into your life there isn't really much incentive to spend time standardizing interfaces for things that can be handled more informally and as needed by the users. As a result those efforts need some internal incentive (like better or clearer documentation) to have development time allocated to them.

I’m successfully using organice to manage my Org files on the Go - on a phone or a different computer.

https://github.com/200ok-ch/organice

Since Org is plain text, it’s a beautifully portable format.

And there’s parsers for many languages like: https://github.com/200ok-ch/org-parser

I'll have to disagree here. I'm using org-mode files even as a Vim user. Because compared to Markdown it has more basic syntax features and is fully compatible with LaTeX, making it both convenient and more powerful than Markdown.

Non-Emacs parsers aren't remotely complete or correct but the same applies to the huge variety of incompatible Markdown extensions and parsers in my experience. Some support tables, some don't, some can't handle standard table of content references.

And while you are right in that the interactive features of org-mode are Emacs exclusive they still are an advantage in my view: they are optional, independent of each other and documented. This means I was easily able to reproduce one of those features with some scripting in Vim while still keeping it conforming with the standard.

I think .org is a fantastic format because 100% of even its most advanced features are still rooted in plain text representation of the information, while its syntax is basically a superset of LaTeX, providing convenient shortcuts of the most common elements of text documents. This makes it universally readable and powerful when needed.

Not that great in my experience, good enough to read and navigate through org files, but lacks many features and has performance issues. vimwiki https://github.com/vimwiki/vimwiki is probably the best note-taking plugin for vim.

I'll just say I opted to write my own org-mode syntax file(for syntax highlighting), file linking and time tracking for Vim instead of using the vim-orgmode plugin. That's enough for my personal org-mode based wiki and some organisational tasks.

The vim-orgmode plugin's performance was absolutely abyssmal when I last tried to use it, with input delays above a full second in some situations.

That's 0.005 usd of hard drives. There is literally no one in the world who could notice the difference.

Justify in terms of what, exactly? At current disk prices, 114 megabytes costs less than a third of a US penny. Even at minimum wage, you'd make that in under a second.

I don't know of a "small" Emacs distribution.

You can have Vim in Emacs with Evil Mode. IMO Emacs bindings are terrible no matter what and modal editing saved my career from an early death by wrist injury. But on top of Vim bindings you also get an entire, programmable IDE. I guess it's kinda big but like, so are most IDEs? But you can get many features at a lighter weight than other ones.

Like yea if literally the only thing you wanna do is edit plain text and maybe at most have syntax highlighting, use plain old vim with some .vimrc setup. If you're finding yourself installing plugins to make vim be more like an IDE, at that point, just install an IDE, and no IDE handles vim bindings better than Emacs imo (and this is from extensive testing), so, there, use Emacs.

Red Dead Redemption 2 on PC is about 150,000 MB.

I have a little bit of difficulty justifying that on my SSD main drive.

114 MB for what is effectively an IDE for the long tail of programming languages is very easy to justify.

Good point, although it's also hard to justify Vim's 18MB vs Ed's 52K.

Look's like Vim is just too bloated for the modern minimalism focused user.