Hacker News Reader

> We seem to be following a trend where "winning" software has little to no learning curves, as they are becoming the simplest possible tools for daily use. I'm not sure if it's a result of the fact that most people are tech savvy, or if we're just getting better at building software and designing interfaces. It's probably some combination of both.

We're following a trend where "winning" software has little to no learning curve, as they are becoming the dumbest possible tools, with ceiling placed so low that no learning is happening at all - in first 5 minutes you get to see all that there is to see. It's the result of UX trends driven by SaaS businesses, where the first impression is what gets the sale, making development concentrated on looks over function.

I don't think the UX needn't be complicated. If you really wanted that you can use .rtf, but whitespace and at least grayscale separation are already possible in plaintext of course. Want a cute header? How about:

##########

Header

##########

Smaller plain text files + folders are great for separating, categorizing, and interacting with information. Got another file type relevant to that note? throw it in a folder with a matching filename.txt describing it all. Have aliases or shortcuts to make these appear in any configuration you want all over your OS.

MacOS also lets you put tags on any file leading to further customization. Throw in Calendar into the mix for reminders (not proprietary Reminders) mail for communication and sending yourself notes when you don't have your laptop, and MacOS has all the features baked into the OS that most notetaking apps drip feed through a poorly optimized app on a subscription and with proprietary formats.

This system works on any computer built in the last 40 years and will probably work on all computers built in the next 40. Lets see a company like evernote last for that long.

our even better then emailing yourself files, you can use something like syncthing and just drop the file into a folder to have it synced to another device. no need for importing and exporting from your email app

It’s worth noting that unless your header text file is in a format that can be converted to HTML, there’s no easy way for third-party accessibility tools to understand your plain text the way you do. Accessibility is one of the reasons WYSIWYG is so common. It’s hard to translate plain text to a semantic verbal description (though with AI and pattern matching this might be getting easier), and even harder if it’s not actually text. ¯\_(ツ)_/¯

Simple is always better, the problem is that "simple" isn't the same for everyone because different people have different needs. Simple is often simplified into "one one size fits all," which often just ends up being limiting.

This. "Simple" so often turns into complex when the system is too brittle to fit your desired use case

I'm skeptical any such trend exists. Are you sure you're not misinterpreting your anecdotal experience?

I'm not sure if it's a result of the fact that most people are tech savvy

Most people aren't tech savvy. Again, maybe you are extrapolating inappropriately from your personal experiences, the people you hang out with, etc?

I'm mostly referring to the younger generation(s) and the apps most widely used by them. Think of the simplicity of applications like Instagram and Snapchat. There isn't much to the interfaces for most user interaction - some images, videos, text, an input or two, and a few buttons. There may be some advanced touch interactions (pinching and swiping), but overall, applications these days tend to be relatively simple.

Older generations definitely struggle using software though, so I think they may be a good metric for how simple and easy to use software can be.

Anecdotal experiences could certainly play a role in my opinion here, but I do think I've recognized a pattern over the past couple of decades where winning software interfaces have made a transition from being overly designed and complex to much simpler designs with (usually) predictable interactive element positions and flows.

Think of what software was like when there were "shiny" buttons and small text everywhere with confusing visual flow, and then think about what it is now, usually composed of flat buttons (e.g., the "material-ui" standard) and easy to digest visual flow with predictable interactions. This transition is likely a natural result of figuring out over time what works best and what doesn't.

By tech savvy people, I mean the end users who interact with software on a regular basis. These people (i.e., most people in the modern world, a number steadily increasing) will naturally gravitate towards the easy-to-use, predictable design patterns to which they've become accustomed.

I find Snapchat to be a confusing and complex app. It’s very hard to figure out how to do what you want unless someone shows you. The UI doesn’t have any discoverability. Many actions are hidden behind non-obvious gestures. Lake many apps nowadays, it gives the illusion of simplicity by just not having adequate UI.

On a related note, I absolutely hate how most mobile and many web and desktop-based apps nowadays don’t have tooltips, so I can’t figure out what some inscrutable icon/button is supposed to do by hovering my mouse on it or long pressing my finger on it. This used to be table stakes.

Yeah, I also find most modern "simple" apps and sites really confusing. Especially if they're social. Even Twitter's confusing as hell, despite doing very little. I bounced off Facebook in about a week back in 2011 or so, and never returned, because I couldn't figure out where anything was or where anything went, and it was less confusing back then from what I can tell.

Apps are simply becuase devices force them to appear simple. Screenestate is limited and inputactions are mostly touch&gesture-based. That leaves not much room for complexity. Even the onscreen-keyboard only has chars by default, not modifier for complex shortcuts.

Completely agree. Everything I publish starts with plain text.

I use the basic text editor that comes with the OS or Ghostwriter [1] when I really want no distractions. It's a great, minimal and distraction free editor I discovered recently when I switched to Linux (it does exist on Windows too and there's a macOS beta).

I put it on full screen with dark theme and focus mode on (it highlights the current line and fades everything else away). When I want to go gung-ho I also enable Hemingway mode which disables the backspace key. Love it.

[1] https://github.com/wereturtle/ghostwriter

> in terms of software UX, I would say plain text should be used as a starting point while adding interactive elements (e.g., buttons) and layouts only as necessary. By layouts I mean visual separation of categorized information via whitespace and/or color variations. I've found that this results in extremely intuitive interfaces that are both easy for users to digest and developers to maintain.

Is there any software that you think stands out as an example of this approach?

Emacs is exactly this. People usually think it's an editor, but I actually think it's better to regard it as the remains of a text-mode Lisp Machine that now happens to be a VM.

In particular, Org leads to very nice and simple text-mode workflows and mini applications. Besides, apparently Amazon used a custom Emacs application (not Org-based) in the early days to do customer service [1].

I actually very much prefer it to Unix ncurses applications, which tend to be little information silos. In contrast, Emacs makes it really easy to connect everything together thanks to great Elisp APIs. It feels like a really cohesive environment. Unix shines for non-interactive workflows.

I like doing my computing in 3 (actually 4 platforms): Emacs, a browser (Firefox), a terminal (XTerm) and F-Droid. That, plus a nice manual tiling WM (StumpWM) and functional plumbing (NixOS) is a great simple setup.

For example, a good keyboard, no compositor and XTerm reduces latency a lot vs more complex desktop environments. It's really noticeable.

[1] https://sites.google.com/site/steveyegge2/tour-de-babel

> In contrast, Emacs makes it really easy to connect everything together thanks to great Elisp APIs.

Elisp APIs and your standard editing commands (which are of course the pieces of Elisp that happen to be bound to keypresses). The difference between this and ncurses/other TUIs is profound - as you said, typical TUIs are data silos, just painting characters on the screen. Whereas in Emacs, all the text on the screen is accessible for search, navigation, copying, and even modification.

Even saying "Elisp APIs" doesn't do it justice; Emacs follows the best traditions of Lisp Machines - you can inspect and modify software at runtime, and make it do what you want it to do, whether it wants it or not. If an Emacs mode (i.e. essentially an Emacs app) doesn't provide some functionality, you can add it either way. Want to use pretty third-party autocomplete like Helm for e-mail addresses in To: field in your Emacs mail client, and want it to pull suggestions from some arbitrary .org file you use as an address book? No problem at all. Few lines of code and it just works.

That's right, API is not something I should have used for Elisp. The only thing that compares is Smalltalk in terms of being a live environment.

The downside is security. You need to trust everything you run, because as you say it's so open and inter-winded.

It’s much harder to build good search engines on top of plain text though, because it’s not possible to deterministically detect hyperlinks within text.

If the word starts with "http" and contains a period, it's probably a hyperlink. HN uses this assumption to automatically convert plain-text hyperlinks, and it works well enough.

The real problem is dealing with SEO spam, not occasional false positives with hyperlink detection.

Sometimes auto-conversion (esp with all the TLDs and gTLDs) has weird outcomes: >> "Rudy Giuliani accuses Twitter of bias for hyperlinking text" | https://www.theverge.com/2018/12/5/18127063/rudy-giuliani-tw...

> The real problem is dealing with SEO spam, not occasional false positives with hyperlink detection.

I mean that's easy to say, the obvious question then is why it's apparently too hard for Google, since they don't do it despite the fact that it would obviously be of value given their algorithm.

Why would it be of value? Google isn't in the business of giving best-quality search results; it's in the business of giving passable search results while exposing users to ads and collecting data for their advertising machine.