
Emacs is special regarding UIs - signa11
https://lists.gnu.org/archive/html/emacs-devel/2020-09/msg00286.html
======
jwr
One begins to understand the advantages of this approach after 10-15 years or
so.

I feel that I am constantly being forced into new "UI paradigms", and it isn't
always a change for the better. I started with DOS (Norton Commander, anyone?
to this day there is no comparable tool), then Windows 3.0 and 3.1 (which was
mostly garbage and I did not enjoy the UI at all). I then started using Linux
and discovered Emacs. When I could afford the extra megabytes of memory, I
would also run X11. As years went by, I switched to the Mac.

These days I'm worried about what will be taken away from me, especially with
Apple and their insistence on removing ports, the idiotic "Touch Bar" instead
of function keys — but also with Linux, where the shift away from X11 means no
more remote applications, and the (increasingly broken) approach of gluing
everything together into a big mudball means that if you're running anything
that isn't "mainstream", things break and you are very much on your own.

But I still have Emacs and I'm fairly confident that it will remain available
and running on every platform I decide to switch to. And that I will be able
to run it (with reduced functionality) on a text terminal.

~~~
hpfr
The shift away from X11 means no more forwarding X11 applications over ssh,
which is slow at best and buggy and insecure at worst. A small price to pay
for eliminating tearing and actually-secure screen locking. There are valid
criticisms of the move to Wayland but I don’t really think this is one of
them; if you really need remote access to graphical applications you almost
certainly should not be using X forwarding.

~~~
GuB-42
At work, we do X11 forwarding all the times. We have a wide variety of UNIX
machines and we often need to run several graphical applications from
different machines (not a remote desktop).

X11 forwarding works with the latest Linux distros as well a 20+ year old
systems running motif apps. Note: the old systems are now virtualized but we
still need them, I work in the aeronautic industry and these are the time
scales we are working with.

I don't know of any replacement, at least not one with that level of adoption.
Again, we really want to run graphical applications on a server, not a remote
desktop.

And BTW, things are getting troublesome. More and more Linux apps integrate
accelerated web browser components and these tend not to play well with X11
forwarding.

Love the irony of using a remote display to show an Electron app BTW.

~~~
billfruit
Not just Electron, even QT as well performs horrible over X11 forwarding in
recent versions...

Things seems to be going backwards in this area..

~~~
louai
When I was at Qt I spent a decent amount of time porting the native rendering
engine from Qt4 to Qt5. It should be available and work relatively well. I
have retired from the Qt project, but it looks like the code is still there in
the repo. [1] You might need to tell the configure script to build it. To use
it, set the QT_XCB_NATIVE_PAINTING environment variable.

[1]
[https://code.qt.io/cgit/qt/qtbase.git/tree/src/plugins/platf...](https://code.qt.io/cgit/qt/qtbase.git/tree/src/plugins/platforms/xcb)

------
dhosek
Wow, it's interesting how many people seem to have their own takeaways from
this, many of which seem to have missed the original point of the post (I
wonder how many actually read the post). The author of the post on gnu.org is
blind (and the "Raman" he referred to is T. V. Raman, a blind mathematician
who I met ages ago when he gave a presentation at the Portland TeX Users Group
meeting about adapting TeX for presenting mathematics to blind readers. Raman,
in fact, wrote a reply to the message where he wrote:

 _> A lot of baggage gets applied today when folks talk about "Accessibility",
but to me the touch-stone of a truly Accessible system is one where you dont
have to ask what interaction modality someone else is using e.g. witness
email, where the persons participating in a conversation never need ask "Did
the person I am talking to use Braille, speech, or something else", similarly,
someone who has a hearing impairment can send you email without you ever
needing to know that he cant hear you._

I feel like too many developers treat accessibility as an afterthought rather
than a central concern.

~~~
sn41
It is an interesting historical note that T. V. Raman won the ACM best
doctoral dissertation award as a blind scholar [1]. I take an active interest
in accessibility partly because my wrists hurt. Technologies initially meant
to help blind people have turned out to be useful for people with other
conditions as well. [1]
[https://awards.acm.org/award_winners/raman_4110221](https://awards.acm.org/award_winners/raman_4110221)

~~~
jberryman
Are there any particular technologies that have helped you with your wrist
issues?

~~~
anitil
Not OP, but I periodically swap my mouse hand, and that seems to be enough
change to ward off my long-standing wrist issues. That and a proper mechanical
keyboard with decent travel in the key stroke are necessary for me to do this
long term.

~~~
sn41
Yes, I do this as well. The improvement is significant, and the relief,
noticeable.

------
dmortin
Emacs is not a text editor, it's a platform independent VM which can run your
scripts with a text UI.

E.g. do you want keep an eye on some information which can be fetched from the
net? You just write a script which regularly fetches the info and puts it into
a buffer, so you can take a look at it anytime, and then regardless of
platform you have that info readily available just by installing your own
emacs config file.

It's much easier to write such things in emacs than curating various different
scripts in various languages (python, etc.) which all require their specific
support which is either available or not.

~~~
roydivision
> It's much easier to write such things in emacs than curating various
> different scripts in various languages (python, etc.) which all require
> their specific support which is either available or not.

I disagree. I’ve been using Unix/Linux for 25 years, I’ve met maybe 1 or two
people who know or use Emacs, whereas almost everyone knows enough to do some
scripting.

I’m also guessing that installing and configuring Emacs is way more work than
installing Python. And any gained Python knowledge will pay you back tenfold
more than learning Emacs.

~~~
indymike
Honestly, getting going with emacs:

$ sudo apt install emacs $ emacs

From there it's learning some keystrokes. Payback? Almost immediate. And you
can use it to work with Python, or any other language. After that, maybe
reading a couple of howtos and installing a few add-on packages and
customizing your configuration. Payback? Almost immediate. It's really
productive.

~~~
jonfw
> From there it's learning some keystrokes

Learning Emacs is VERY clearly not this trivial... to use Emacs to any extent
where it's more useful than it's competitors, you have to learn the models it
works in, a new programming language- and then there are a LOT of keystrokes

~~~
jerf
I... uh... am almost in some sense ashamed to admit this, but I've been using
emacs for about 23 years now, and I still don't program elisp. I can just
about diagnose errors in my not-very-complicated .emacs with a bit of
googling, and that's about it. I've read about it, and I understand the
basics, but I know nothing about the APIs and have no experience in it past
one-liners.

It probably is a good idea to learn it, in some sense, and you'll probably
have to pick up at least the basics that I've picked up, but it's definitely
not a commitment to learn a new language.

~~~
pmoriarty
Using Emacs without knowing eLisp is like owning a race car but always driving
it in first gear.

~~~
jerf
I can deal with that metaphor, if "a race car in first gear" is still faster
than a lot of other cars.

Plus, it's the same race car. I've programmed half-a-dozen languages quite
seriously in emacs, and I'm not changing editors the whole time. So, while I
may not know elisp, I do know a fair amount about emacs and don't have to
relearn how to do a lot of things in a new IDE every three years... or, worse
yet, discover that entire features are missing because "nobody" has ever used
an editor that had them. (I'm not sure I could live without macros of some
sort in an editor.)

------
bartread
This is somewhat oblique to the content of the post but "special" is about
right. "Unnecessarily obtuse", particularly from a contemporary perspective,
might be a less kind way to describe it. I could say the same about the
documentation which, frankly, is not great at making you immediately
productive. It's written like an academic treastise, not a tutorial for a
piece of software that exists to help you get stuff done and where learning
the software is not an end in itself.

I've recently started making a relatively determined attempt to become
proficient with emacs due to increasing frustration at poor performance from
both VSCode and Sublime Text when working with larger projects and, I'm not
going to lie, it's hard going.

Take something as basic as working with multiple windows. Emacs has concepts
of buffers, windows, and frames, but windows and frames are diametrically
opposite in concept to windows and frames in client side web development.

That's not too difficult to grasp but, say you're in dired, and you want to
open a file in a new OS window (in emacs-speak this would be a frame). You'd
think you could just move the caret over the filename and hit some key
combination to open that file in another window (sorry, I mean frame).
Possibly you can but the nearest I've managed to get so far is (from memory)
C-x 5 f, which brings up the minibuffer prefilled with the pathname of the
directory you're browsing in dired, and then you have to start typing the
filename (which, granted, will autocomplete), which seems somewhat redundant,
and only then can you open the file.

It's also full of things to trip you up, like the key bindings for switching
to another (emacs) window and killing a buffer - both fairly common operations
- being far too similar and easy to confuse for a newbie.

It just seems so deliberately contrary, but I'm hoping the investment will pay
dividends given time and persistence (this is, however, approximately my
fourth or fifth attempt in 20 years to learn emacs, so we'll see).

~~~
fennecfoxen
As a long time emacs user, I can confirm that emacs is terrible... and
everything else out there is deficient. I can write custom code (ew, elisp) to
determine how to switch between buffers (test buffer and code under test) and
I can run my tests and find operations and the like in a first class buffer
and a dozen things like that which are just incredibly painful in other
editors.

Also I hit Cx-c by mistake thrice a week.

~~~
joosters

      ;;; Make it more difficult to kill emacs accidentally
      (defun my-kill-emacs ()
        "Confirm before 'save-buffers-kill-emacs'."
        (interactive)
        (if (y-or-n-p "Really kill Emacs? ")
            (save-buffers-kill-emacs)
          (message "Aborted")
          )
        )
      (global-set-key "\C-x\C-c" 'my-kill-emacs)

~~~
jimmyvalmer
Dude, `M-x custom-set-variable RET confirm-kill-emacs RET TAB`

~~~
morelisp
Or just unbind it, you won't typo `M-x kill-emacs`...

~~~
fennecfoxen
TBH it actually helps me a little. I seldom lose any work at all, and I have
to remember to commit editor config changes somewhere persistent. :P

------
submeta
Emacs + org has the potential to be the dream environment for everybody with a
hacker mindset: Automate everything that has to do with text: Journaling,
writing todo lists, parsing your Kindle highlights file (`My Clippings.txt'),
writing project outlines, doing web research and saving your searches, notes,
thoughts, summaries in Emacs via org-capture, drafting papers in org-mode,
creating (text-based) tables and overviews, writing tech documentation with
embedded screenshots, and many many more.

What ties all these notes and files together is Emacs Lisp: Write Lisp
functions to automate most of what you do. - Previously I used Python for
that, but Elisp is so much more fun to automate text-based workflows.

I would have to write a book to summarize all the ways this can transform your
interactions and workflows with your computer and especially with everything
text.

Edit:

After twenty years of using all sorts of text based databases and PIMs
(AskSam, NetManages ECCOPro, various outliners, Outlook, Evernote,
Omni{Focus,Outliner}, Bear Writer App, Ulysses App, and half a dozen other
tools) I have come to realize that nothing beats Emacs + Org + Lisp.

~~~
agumonkey
I hate org.

I use emacs 25/7, I hate org.

Something about it rubs me the wrong way, yet I use it but only the basic
parts. I think it's that I can't wrap my head around the mental model of it,
and since it encompasses 2000 topics (trees, timing, workflow, states, agenda,
journaling, tagging) it's like a mountain of mud before my eyes.

~~~
blablablerg
Well you don't even have to understand it fully, that is what is great about
it.

What it is good for is that it gives you maximal freedom in organizing things
the way you want. When I start out with a new org file, I just make lists and
add functionality when needed.

While with most other todo/organizing applications you tend to be forced in
some framework. This is how you should organize, and when you want to deviate
things become cumbersome.

And then the other good thing is that editing is FAST (I use evil mode), in
most other organizing/productivity tools you have to click a lot. Simple
things become a chore quickly.

Freedom + speed = gold

~~~
agumonkey
oh you're assuming that not using org means using another organizer[0].. I
just stopped organizing :D

who knows, maybe one day I'll finally see the light

[0] and I fully agree that most systems are way less ergonomic than emacs

~~~
blablablerg
Haha yeah I also never planned, I hated it. Still do actually. But one day I
was fed up with the chaos in my life, dirty house and minimal productivity
that I decided.. I need structure. I realized that the time I invest in
structure pays itself out, because I spend less time goofing around. And so
started the great journey in finding the best todo system. I started with
paper, then google calendar/tasks, todoist and load of other apps until I
finally went back to paper. The apps were just too cumbersome. Paper was
simple and worked, but unfortunately paper itself is difficult to organize. I
always avoided orgmode because well.. I was scared of emacs but eventually
decided to give it a go, see what happens. And it was what I have been looking
for all along: a simple and flexible system. And vim keybindings are a big
bonus :)

------
II2II
Most of the comments seem to be missing a very important point from the post:

> As a blind user, I can write a special mode which does something specific,
> say, implement an IRC client. Almost all my work can instantaneously be used
> by sighted people using their graphical toolkit.

This goes well beyond the ability of the author to create software that is
accessible for both sighted and blind users. It is stating that support for
both audiences is handled elegantly by the same toolkit, so you aren't
creating an adversarial situation where serving the needs of both groups of
people requires some form of compromise in the user interface or necessitating
significantly more effort. (I would imagine that some care is required, but
Emacs developers are going to address it anyhow since the program is intended
to run in graphical and non-graphical environments.)

I suspect this support of multiple environments is part of the reason why
there is an esoteric collection of applications that run within Emacs. As an
example: it is possible to read ebooks in Emacs, with formatting and images
being supported in X and gracefully handled in a terminal.

------
Cthulhu_
Emacs and org-mode is frequently mentioned on HN as being awesome, but I don't
feel like I could ever switch; I've got enough issues with vim already.

For one, all the keyboard shortcuts and commands that you have to learn; I
don't know if I have the capacity to learn all that anymore, not without
deliberate practice, while in modern editors you can get by with keyboard +
mouse and slowly learn some new shortcuts here and there.

Second, it feels like you have to spend a lot of time to set it all up.

Third, will it replace an IDE? Error checking / linting, autocomplete, fast
navigation, auto-imports, loads of things like that that seem to just work
out-of-the-box in e.g. idea.

~~~
hpfr
I feel like it’s pretty safe to say [https://github.com/hlissner/doom-
emacs](https://github.com/hlissner/doom-emacs) mostly solves of these concerns
for Vim users in 2020. If you really can’t spend any time learning a few help
keys then I guess I can’t recommend anything, but you’re here commenting so I
bet you have some time :).

Seriously, check out Doom, whether you use neovim, Emacs, VS Code, or nano
(Doom has quite good Emacs and CUA bindings as well). It’s brilliant to the
point where I’d describe it as Emacs with sane defaults. I guess it probably
can’t match the more niche IDE features but LSP and friends are bridging most
of the gaps.

You can finally safely ignore claims that beginners should roll their own
emacs configs thanks to Doom. That strategy is good for learning if you’re
used to diving into unfamiliar systems but you can learn just as much by
starting with Doom and working your way inward anyway. The community is great,
just like the larger emacs community.

I can’t stress Doom enough; it gets better often not by the day but by the
hour. Henrik is a machine.

~~~
RMPR
> I feel like it’s pretty safe to say [https://github.com/hlissner/doom-
> emacs](https://github.com/hlissner/doom-emacs) mostly solves of these
> concerns for Vim users in 2020

I use both doom emacs and neovim, and I'd say: not really, at least not for
me, there are some Vim features evil doesn't emulate properly, or at least it
doesn't work like in Vim. Off the top of my head, I write in many languages,
but absolutely hate the US international keyboard for accented characters,
guess what? Vim has built-in support for digraph[0] by using Ctrl-k and iirc
this is a motion keyboard shortcut in emacs, and since I like and use org-mode
a lot, I'm always frustrated when I have to type in another language. Another
one was with the various Terminal emulators packages in emacs, although this
one was solved recently[1], whereas in (neo)vim it works flawlessly ootb.

0:
[https://vim.fandom.com/wiki/Entering_special_characters](https://vim.fandom.com/wiki/Entering_special_characters)

1:
[https://news.ycombinator.com/item?id=24243031](https://news.ycombinator.com/item?id=24243031)

~~~
WhatIsDukkha
[https://github.com/emacs-
evil/evil/blob/3f3b2fea87172f155e5f...](https://github.com/emacs-
evil/evil/blob/3f3b2fea87172f155e5f91d75f0fb69d8648acf2/evil-maps.el#L369)

It's defined in Evil (which Doom uses directly).

Seems like you just need to figure out your bug.

~~~
RMPR
Thanks for pointing this out, seems the "bug" is exclusively with org-mode,
which is too bad because I don't usually need this feature outside of org-
mode.

~~~
WhatIsDukkha
Works for me in my org-mode and evil but I'm not using Doom.

Fwiw use-package is pretty magic and reliable these days.

------
vbsteven
To me the main 2 primitives that make Emacs the extensible crossplatform
app/platform/os/whatever you want to call it are these:

* everything is a buffer, which in essence is a grid of text, that's the UI primitive, if you can render a grid of text you can probably build an emacs UI easily.

* every action/command is an elisp function that operates on these buffers

Combine these two and you can create pretty much anything. Code written in
elisp that outputs buffers.

An analogy with the modern web as a platform: elisp is the JavaScript and
buffers are the DOM.

------
smitty1e
For those with wretched joints (me), Spacemacs[1] is a way to have all that
org-mode[2] functionality, the joys of magit[3] and have it all work well over
SSH.

Leave all the icons to their fans.

[1] [https://www.spacemacs.org/](https://www.spacemacs.org/)

[2] [https://orgmode.org/](https://orgmode.org/)

[3] [https://magit.vc/](https://magit.vc/)

~~~
mkesper
After finding doom-emacs, I love that even more. Almost instant startup, non-
broken magit key bindings, doom doctor etc.

[https://github.com/hlissner/doom-emacs](https://github.com/hlissner/doom-
emacs)

~~~
DreamyCori
It seems like doom-emacs is the new way to go. I feel quiet sad about this
cause I spent some time to switch to Spacemacs and now I have to move to
another emacs distro.

~~~
dunefox
Why do you have to move? Are you using the dev-branch Spacemacs or master?

~~~
DreamyCori
master cause I want something stable.

~~~
dunefox
I'm on dev and it's quite stable, imo. Then again I'm not a spacemacs
poweruser so...

------
skissane
I can think of a few UI styles Emacs doesn't support (to my knowledge) – line
mode terminals, block mode terminals (such as IBM 3270 and 5250), and HTML.

Now, whether any of those UI styles are actually _worth_ supporting is a
completely different question. But it is not quite as universal in support of
different UIs as this email claims.

(You can technically write line mode applications in Emacs Lisp, try `emacs
-batch -l dunnet` for an example. But most Emacs functionality is not
available in line mode, the core text editing functionality certainly isn't.
There is also a HTTP server available for Emacs [1], so you could use it to
implement a HTML-based user interface, but once again the vast majority of
Emacs functions are not available over HTTP)

[1]
[https://www.emacswiki.org/emacs/HttpServer](https://www.emacswiki.org/emacs/HttpServer)

~~~
rusk
Interesting ... has anybody tried a browser based (which is what I presume you
mean by HTML) front end for emacs?

EDIT - just to be clear, I'm talking about emacsclient, talking to a emacs
server. Not an actual full blown emacs implementation that's just stupid.

~~~
dheera
With the new Chrome filesystem API it should be possible to make a full
browser implementation.

Let's just hope they don't have annoying GDPR and other popups when you're
trying to edit a file.

~~~
rusk
You shouldn't even have to need filesystem API if you're just using it as an
emacs client connecting to an emacs server.

Your remark about GDPR is kind of strange ... not sure what that would have to
do with anything ... GDPR applies to people and organisations, not their
tools.

~~~
NateEag
The requirement to advertise "we use cookies" and spam you with popups when
you visit a site is frustrating for highly technical users.

OP is saying that Emacs-as-website would be frustrating if it had those
popups.

~~~
rusk
You don’t have to do that unless you’re hosting a public site ... and even so
if it’s a private session and you’d logged in this wouldn’t be required.
Logging in is seen as a tacit acknowledgment that you consent to being
tracked, cause how would I have. A personal session otherwise.

The cookies warning is all about notifying the casual reader who might
otherwise believe they were passively browsing static content.

~~~
krageon
> Logging in is seen as a tacit acknowledgment that you consent to being
> tracked

Logging in means you get a single cookie (a login/session cookie), that cookie
is necessary and thus a functional cookie that you can't say no to. All other
cookies (and basically every form of tracking) still isn't allowed without
consent.

------
mullikine
I wish to profess my love for terminal emacs. I do not take it for granted.
Hear ye. Any editor so powerful that also humbles itself to a 100x30 terminal
without losing any power is pure class. This program deserves praise. I pray
that GNU emacs will continue to support a text-only interface for many years
to come and when at last the elisp fractal is no longer fit for purpose, I
pray that its mechanics will be absorbed by the great neural network that will
learn everything.

------
fierarul
I thought it will be a criticism how everything seems _off_ with the Emacs GUI
from the copy-paste to the font rendering to the way scrolling is done, etc.
I'd guess it managed to be so cross-platform by re-implementing everything,
kinda like Java Swing but with less care for design.

Now I understand how having a scriptable and text-based foundation would help
with accessibility, just Emacs wins no UI contest.

~~~
hpfr
I don't know if I'd call it _re_ implementation when the original Emacs is
older than DOS and GNU Emacs, still maintained today, is older than Windows
(1985). Emacs's keybindings, font rendering, and scrolling were just as valid
then as any other approach. Let's at least avoid comparisons to Swing :).

You can bind copy-and-paste as well as any other text wrangling functionality
to whatever you want and there are ways to make it behave like other platforms
without too much difficulty. But why hamstring Emacs' copy and paste by
limiting it to the simplistic version we're used to when you can copy to
multiple registers and have a searchable history of copied text?

Font rendering uses Harfbuzz in the latest version and is quite good in my
opinion, there's even color emojis. Scrolling is certainly better than any
terminal emulator I've used, although there's no smooth scrolling. I guess
everything is _off_ if you're comparing it to a browser, but modern browsers
aren't exactly paragons of UX either. But if you're comparing prettiness
options like these, yeah, Emacs loses to VS Code. All Microsoft had to do was
build a text editor on top of a browser engine to get those features :). I'd
say Emacs is more extensible, though. Lisp machines and all

~~~
fierarul
I understand, but 35 years have passed, no need to stick to the original
implementation that long.

I'm a super basic user and nowadays basically have Emacs open all day just for
org-mode. Nothing else.

To me it seems a terrible text editor and has an UI that's foreign on macOS
and Ubuntu. It's unclear to me under what OS/Window manager/etc Emacs fits
right at home. It seems out of this world.

I can imagine there may be some configuration that would fix some of these
problems, but I just use Emacs as it comes out of the box.

~~~
Jtsummers
A reason to stick so closely to the original model is that it has lasted 35
years. There are few other programs that have lasted as long without feeling
an urgency to change with the times, and mostly by the base system being
similarly stubborn about changing or by being incredibly simple.

The fact that it's, essentially, the same on every OS I use it on is another
selling point. I bring my .emacs file and make minor tweaks for different OSes
(due to where files/programs are if absolute paths or relative paths in the
user home directory are different). It always works the same once I've made
those small changes (and they are small, and once done my Windows .emacs is
good on any Windows box). Again, there are few other programs like this. At a
minimum, you often end up with subtly different keybindings (macOS using the
command key, Windows using control, and Linux using control or alt) and subtly
different layouts that break workflow and habit.

~~~
newen
Yep! Main reason I use emacs is that I can use just about the same workflow
when I'm programming in python, C++, etc. in different environments like
windows gui, windows WSL, linux GUI, linux terminal, remoting through ssh, ssh
into docker container, etc.

------
benreesman
IMHO emacs is kind of a Rorschach test w.r.t. Lisp. Some people really like
programming in Lisp, and for them getting emacs to do what they want is fun
and rewarding, particularly but not exclusively regarding interface
affordances. I personally fall into this category. The fact that it has very
similar keybindings to readline/bash (especially important if you spend a lot
of time popping on and off servers that don’t have your dots and thus choose
not to customize the shell too much) and macOS is a huge bonus.

But I totally get that this is from outer space for another group. Vim is a
great alternative for people who want a more opinionated editing wizard mode,
and VSCode is really competent at interacting with remote filesystems and
supporting lots of languages for the GUI crowd. It’s a great time to be
editing text.

~~~
lc9er
I'm a (neo)vim user that's been playing around with various Lisps lately. CL
and Scheme interaction is worlds ahead in Emacs, but even with evil-mode, I'm
having a hard time. There's lots of places where it just stops working, and I
have to remember Emacs bindings. Emacs 27 and 28 are more responsive,
especially on Windows, but vim actions are near instantaneous.

A cool project I stumbled across is Aniseed[0], which thanks to Neovim's Lua
bindings, lets you control neovim with Fennel. I haven't done anything
noteworthy yet, but for the first time it actually seems like it would be fun
to write my own plugins.

[0] - [https://github.com/Olical/aniseed](https://github.com/Olical/aniseed)

------
blauditore
Slightly off-topic, but people here seem to like that stuff: The author has a
personal website[0], which is a gem from the "old internet" \- a wild mix of
technical stuff, pet cat pictures, and some personal history.

[0]: [https://delysid.org](https://delysid.org)

~~~
sreevisakh
Very interesting! Made me curious about how a blind person codes
(accessibility technology). Aside from that, I am also curious as to why you
characterize the website as from the 'old internet'. It looks like a modern
minimalist static site to me. Not what I would expect from a 90s site. What do
you consider as the distinguishing features of old internet vs the modern
version?

~~~
blauditore
Well, my classification of it as 'old internet' is of course subjective. To me
it feels like many newer websites appear more clinical, in both, positive and
negative ways. I think it's way less common now to mix personal stuff like pet
photos with more professional topics like coding. Poeple who post both usually
do this on different platforms (social networks vs. personal blog).

From a technical point of view, the website makes heavier use of tooling that
nowadays are used less, because there are alternaltives. One example are
actual hyperlinks and different pages, whereas today there's some trend
towards keeping more content on a single page and use buttons to navigate it.

------
robenkleene
What's the difference between what's being described here and the web?

(In particular, Electron-based local applications which of course have a
cross-platform web-based UI.)

I'm not saying they aren't different, at the very least, Emacs prioritizes
text, while the web prioritizes multimedia. But I'd love to hear other peoples
takes on the differences.

~~~
slightwinder
The Webstack is far more complex than anything emacs offers. Emacs has just a
wall of text with some special markup, but there is not concept of layout for
this text, and all navigation is usually separate from the wall of text,
making accesability significant simpler to handle.

In emacs there is a beginning and an end, and you just follow the flow. In
webstack you have elements, which have a position and if you are lucky they
are tagged with their purpose. If not, it's up to you to figure out whether
this is for navigation or content or advertisement or some other navigation or
comments, which is more another kind of navigation... Basically there is just
no really realiable structure with the web. Sometimes there is something,
sometimes not, sometimes it's this way, next week it can be that way...

And even worse are dynamic site where parts of the site are loaded on demand.
So you need a complex setup of tools to handle those content, instead of
simple text-search and cursor-moving.

~~~
shawnz
You could construct the same kinds of problematic UIs in Emacs too... it's
just that Emacs is not as widely used as the Web and its users don't have such
varying demands and use cases for it, so it's not as common for that to
happen.

The Web is also designed around a linear flow of text. The Web also provides
opportunities to make navigation semantics clear. The Web also implicitly
supports keyboard navigation everywhere. etc. Although many websites try to
work around those principles, is that a problem with the web or just the
websites people are using today?

~~~
slightwinder
> You could construct the same kinds of problematic UIs in Emacs too...

If you do it on purpose, then maybe, but not to the degree of what webstack
offers. People already have a hard time to handle org-mode-hierachies and
folding...

> The Web is also designed around a linear flow of text.

No, that went out the door when CSS was added. Now it's designed around random
positioning of little boxes. Some boxes contain linear text, some contain
media, most contain even more little boxes.

Emacs does not have those boxes in the first place. The only boxes it has are
outside the document, avoiding this whole class of problems for accesability.

~~~
shawnz
Sure it does. First of all, you can lay text anywhere you want in a buffer,
thus letting you create whatever little boxes you want. Plus, it has support
for images and even arbitrary GTK widgets in that buffer too.

Remember before CSS, people just did the same thing anyway with tables. CSS
only made easier what people were already doing. I am sure the same would
happen to Emacs if it ever became a widely used piece of software.

~~~
slightwinder
> Sure it does. First of all, you can lay text anywhere you want in a buffer,

Does the emacs-api directly support this or is it just some hacked up solution
everyone must do on their own? Of course can you emulate boxes and any kind of
layout-sytem, but whether it's a general supported solution or just some ugly
hack that has no backing in the general culture of a software, makes a
significant difference. It's the difference between 99% of all encountered
content is problematic for accesability or just 1%.

------
hosh
This is something Richard Stallman has advocated for. Free software was not
just about the availability of source code, but also about making sure
software can function well on lower powered devices, lower bandwidth
environment, or people who cannot use the same kind of interfaces.

There was an essay discussing this ... but I do not recall it now.

------
etaioinshrdlu
Not that it's anything like Emacs, but would SIM Application Toolkit be
considered kind of similar? It provided almost a lowest-common-denominator
user interface for apps, which could actually run in the smartphone era,
although with practically no advantages over a native app.

~~~
venamresm__
You'd be surprised to hear STK is still in use even today by big mobile
operators. Some even go as far as to launch campaigns to install STK applets
on millions of devices and customers have no idea this is happening in the
background.

~~~
yaantc
Yes, all the "eSIM" over-the-air management uses the STK for example. But to
be fair, the user interface part is no longer used. The part of the STK still
in use is what is required to support remote management functions between the
network operator and some applet on the SIM card. The user is out of the loop,
and it's perfectly fine for a modem not to support the user interaction part
of the STK.

~~~
venamresm__
I actually work within the eSIM ecosystem and other sim related activities.
And, yes, some mobile operators do indeed use the STK UI today, it's not
limited to background tasks.

------
melling
Emacs Lisp is slow. There has been a multi-decade effort to make Guile support
ELisp, and using Guile to make Emacs more performant.

Cross platform UI, with a faster Lisp, would allow Emacs to be even more
special.

~~~
5h
As a non Emacs user, is the speed of Emacs Lisp a frustration in typical day
to day usage?

~~~
jmiskovic
What are you using now? If VScode or Atom you won't feel any degradation. If
vim or SublimeText, some things will take few extra dozens of milliseconds.
You could test the Doom Emacs, which is trying to be a feature-full emacs
environment optimized for speed.

~~~
5h
I've been using Vim for a very long time now, recently adding CoC has slowed
things a bit however I am quite fond of some of the features, so I might start
enabling it only when I want those.

I'm not looking to encouragement to change (after 20 years in Vim that ship
has likely sailed for good), I was just curious if the speed of Emacs lisp was
a frequent bugbear.

------
argb
One of the nice things about the terminal is that things stay consistent for
decades or more - people are not chasing fashion trends all the time, as is
happening with the Web and graphical UIs.

Nobody is being forced to use a particular style and color scheme and we don't
have repeated redesigns which remove functionality for the sake of user
friendliness or minimalism.

~~~
wiz21c
This. Plugins deliver value much more than graphical design. I also often tell
myself that working in emacs is exhausting because it displays only valuable
information => my brain works 100% of the time when I'm in front of it :-)

------
rleigh
Some of its paradigms are plain stupid.

C-Z (in the GUI) triggers minimise of the window.

In a shell, that's fine. It suspends the process. In a GUI it is just bloody
annoying. There's a perfectly good minimise button if I want it. This is just
a frustration every time I fat-finger C-X. Which is used so frequently it's
just asking to be pressed by accident.

~~~
tom_
I don't rate this shortcut either, but there's an easy fix for your .emacs:

    
    
        (when window-system
          (global-unset-key (kbd "C-z")))

~~~
rleigh
Thanks, that will certainly reduce my frustration a little bit!

------
jmiskovic
How does emacs UI work? It seems like each script is registering commands it
can run in context of mode, and then you can bind key combos to commands. How
do textual UIs do things like layouting of controls, updating of values and
handling async requests?

~~~
ywei3410
> How does emacs UI work?

Emacs has the idea of _buffers_ which are the actual window panes that you can
view. The _buffer_ has data in the form of text which has properties in much
the same way a block of html can have properties. An emacs-lisp function has
full access to do anything it wants with the buffer. For example it can insert
contents, change the font family, change the bit of text into a button with a
callback. This is exactly how syntax highlighting/semantic highlighting works
in emacs, you just change the styling for bits of text [1].

A _mode_ inside emacs is a collection of emacs-lisp functions which trigger
(usually on a file extension name). Typically they will set certain
keybindings for specific mode-like behaviour. You always have a single _major_
mode and multiple _minor_ modes - the vim emulation layer, for example is
simply a minor mode which adds the vim keybindings and emulates the vim state
machine inside emacs-lisp.

> It seems like each script is registering commands it can run in context of
> mode

An emacs-lisp file can be _evaluated_ in the same way as a python file into
emacs. It's like a REPL - you can evaluate a file and the functions become
available. There's a bit of extra behaviour which allows lazy loading et
cetera, but user defined scripts are first-class and there's no distinction
between them and those which are "native".

> updating of values

You can update a variable by simply evaluating the appropriate lisp function.
If you want to update a value in the text buffer, you just replace/rerender
that chunk.

> handling async requests

A buffer can also have a _process_ running which gets events each time the
buffer is updated. When you run a command, you direct the output to a buffer
and you trigger your lisp function on certain events. This is sort of how the
HTTP requests work, but there's libraries which abstract some of it for you.
Buffers are really just an abstraction for textual data.

Some of this is simplified, but I hope it gives you a vague idea of what emacs
is.

[1]
[https://www.reddit.com/r/emacs/comments/iemo44/wysiwygified_...](https://www.reddit.com/r/emacs/comments/iemo44/wysiwygified_org_mode/)

~~~
axilmar
In other words, Emacs has its own markup language? how does emacs know that a
specific bit of text is a button, for example?

~~~
juxtapose
Yes, Emacs supports a limited form of "rich text". See text-mode.

It's supported by text properties [1] and overlays [2]. Character properties
are special attributes attached to a single character, while overlays can
attach attributes to a "region" and override old text properties (like div in
HTML).

In Emacs,

> A button is essentially a set of text or overlay properties, attached to a
> stretch of text in a buffer. [3]

The Emacs display engine is sorta like an HTML render engine.

[1]
[https://www.gnu.org/software/emacs/manual/html_node/elisp/Te...](https://www.gnu.org/software/emacs/manual/html_node/elisp/Text-
Properties.html)

[2]
[https://www.gnu.org/software/emacs/manual/html_node/elisp/Ov...](https://www.gnu.org/software/emacs/manual/html_node/elisp/Overlays.html)

[3]
[https://www.gnu.org/software/emacs/manual/html_node/elisp/Bu...](https://www.gnu.org/software/emacs/manual/html_node/elisp/Buttons.html)

------
larsbrinkhoff
Emacs is a manifestation of the ITS user interfaces. They all relied on text
because that's all that was available back then. They also used control
characters, Altmode/Escape/Meta, and prefix arguments.

------
code-faster
unix is also User Interface Independent, but unlike emacs, it's actually used
on a wide variety of interfaces: Mainframes, microcontrollers, web servers,
phones (touch screen) and PCs.

~~~
neolog
Pretty sure emacs is used on all of those

------
jancsika
> Emacs is the only serious program I know which manages to be truely user
> interface independent, in addition to being platform-independent.

So tell me about the UX of free software speech recognition in emacs. I want
to read about how to set that up and the limitations of it as I watch my 5
year-old niece interact with Alexa.

------
john4532452
> I seldomly hear this property mentioned by anyone else, so even if it
> scratches OT-ness

What does "OT-ness" stand for ?

~~~
CKN23-ARIN
Off-topicness

~~~
john4532452
I could not find that in urban dictionary or google results.Is this commonly
used in free software or open software mailing lists or did you just guessed
it ?

~~~
detaro
OT for "Off-topic" is a very common abbreviation online, yes.

~~~
I_complete_me
Is there a common abbreviation online for On-topic? If so, what is it?

------
jefftk
A website can have this cross-modality UI property too, but most sites don't.
This is partly cultural (emacs mode developers generally caring more) and
partly about collaboration (it's much easier to upstream issues with an emacs
mode than a site).

