Live data from Hacker News

The terminal of the future

jyn.dev

141–150 of 174 posts

Re: The terminal of the future

#141
Make the terminal very simple and easy to understand.

Rid us of the text-only terminal baggage that we deal with today. Even graphics are encoded as text, sent to the terminal, then decoded and dealt with.

Plan9 had the terminal right. It wasn't really a terminal, it was just a window which had a text prompt by default. It could run (and display!) graphical applications just as easily as textual applications.

If you want a terminal of the future, stop embracing terminals of the past.

Re: The terminal of the future

#142
post #74

Why does the successor to the terminal need to be text oriented at all? Maybe it is an API. Maybe the kernel implements this API and it can be called locally or remotely. Maybe someone invents an OAuth translation layer to UIDs. The API allows syscalls or process invocation. Output is returned in response payload (ofc we have a stream shape too). Maybe in the future your “terminal” is an app that wraps this API, auth…

Plan9 shed the textual terminal baggage we all carry today, and it did so in 1995.

The terminal of plan9 was just a window. By default you got a shell with a textual prompt, but you can launch any graphical application in there or any textual application. you can launch a 2nd window manager with its own windows. you can run doom. you can `ls` and `ssh` all you like. it all just works.

this debuted in Plan9 in 1995 or so. 30 years ago we had the terminal of the future and the entire world ignored it for some reason. I'm still a bit mad about it.

Re: The terminal of the future

#143

Earlier quoted context omitted.

Many HN readers grok software development, would likely get a kick out of learning Emacs Lisp, and have time to invest in coding and debugging. Emacs is not as clumsy or random as modern user-hostile software -- it's an elegant tool for a more civilized age, and as such is not for everyone.

> Many HN readers grok software development, would likely get a kick out of learning Emacs Lisp, and have time to invest in coding and debugging. but why would they? what problems are they solving by being able to paste text into your web browsers address bar? or load a pdf into an LLM? or some other incredibly specific-to-you ability youve added? if simply adding a lisp interpreter to a program is enough to impress…

> or some other incredibly specific-to-you ability youve added?

You're saying this with derision, but the ability to quickly add "incredibly specific-to-you" features is precisely what is so cool about it!

Re: The terminal of the future

#144
post #74

Why does the successor to the terminal need to be text oriented at all? Maybe it is an API. Maybe the kernel implements this API and it can be called locally or remotely. Maybe someone invents an OAuth translation layer to UIDs. The API allows syscalls or process invocation. Output is returned in response payload (ofc we have a stream shape too). Maybe in the future your “terminal” is an app that wraps this API, auth…

> Why does the successor to the terminal need to be text oriented at all? Terminals are not "text oriented". They are based on a bidirectional stream of tokens - that can be interpreted as text, or anything else. That simplicity allows for Unix-style composition. If you make the output something different, then the receiving program will need to be able to parse it. The Amiga OS had some interesting ideas with differ…

> One way to add some level of complexity is to add JSON output to programs. Then you can push them trough `jq` instead of `grep`, `sed`, or `awk`. Or push it through another tool to make a nice table.

That's still text. Even PowerShell passes objects between commands.

Plan9 did this correctly. A terminal was just a window which could run graphical applications or textual applications. Locally or remotely. It all worked. You create a window, you get a shell with a text prompt. You can do text stuff all day long. But maybe you want that window to be a file manager, now? Launch vdir, and now that same window is home to a graphical file browser. close that and remote into another plan9 machine. launch doom. it runs. it all just works, and it all works smoothly.

And the entire source code for that OS could fit into one person's brain.

It is a very simple OS, appears (to my layman eye) to have sandboxing between all applications by default (via per-process namespaces) making it very easy to keep one application off of your network while allowing others to talk via network as much as they want, for example.

Re: The terminal of the future

#146
post #74

Why does the successor to the terminal need to be text oriented at all? Maybe it is an API. Maybe the kernel implements this API and it can be called locally or remotely. Maybe someone invents an OAuth translation layer to UIDs. The API allows syscalls or process invocation. Output is returned in response payload (ofc we have a stream shape too). Maybe in the future your “terminal” is an app that wraps this API, auth…

Totally agree with all of your comment. To solve for structured data instead of everyone writing parsers, I’ve enjoyed using nushell (not affiliated, just love the idea). https://www.nushell.sh/

It’s like powershell but not ugly and not Microsoft.

Re: The terminal of the future

#147
I'll cop to not reading the whole list before commenting, but I skimmed this and didn't really notice anything about speed or performance.

When using tools that can emit 0 to millions of lines of output, performance seems like table-stakes for a professional tool.

I'm happy to see people experiment with the form, but to be fit for purpose I suspect the features a shell or terminal can support should work backwards from benchmarks and human testing to understand how much headroom they have on the kind of hardware they'd like to support and which features fit inside it.

Re: The terminal of the future

#149
My terminal is the only user-friendly way to interact with a variety of system resources on linux (generally, implicitly because of the filesystem API). I don't go to view where named pipes are in vscode, I go to the terminal and understand the problem structure there, especially when autogenerated pipelines come into the mix. If I need to look at daemons or tune perf, I also reach for the terminal.

Any solution has to address this use case first, IMO. There are some design constraints here, like:

- I don't care about video game levels of graphics - I generally want things to feel local, as opposed to say some cloud GUI - byte stream model: probably bad? But how would I do better?

as just a few examples I thought of in 10 seconds; there's probably way more.

I've thought about the author's exact complaints for months, as an avid tmux/neovim user, but the ability to interact with system primitives on a machine that I own and understand is important.

But hey, those statements are design constraints too - modern machines are tied somewhat to unix, but not really. Sysadmin stuff? Got standardized into things like systemd, so maybe it's a bit easier.

So it's not just a cynical mess of "everything is shit, so let's stick to terminals!" but I'd like to see more of actually considering the underlying systems you are operating on, fundamentally, rather than immidiately jumping to sort of, "how do we design the best terminal" (effectively UI)? The actual workflow of being a systems plumber happens to be aided very well by tmux and vim :)

(And to be fair, I only make this critique because I had this vague feeling for a while about this design space, but couldn't formalize it until I read this article).

Re: The terminal of the future

#150

I wish people would stop back-porting new features into vt terms, since those “features” gradually leak into terminal programs, which start spewing garbage in older terminals at the next update. Instead of having a standard, we get ESC[whatever-the-fuck-i-feel-like; , but with vt220 characteristics. Missing out on inline images and megabytes of true-color CSI codes is a feature, not a bug, when bandwidth is limited.…

Effectively you have to use tmux or screen as a condom at that point - programs that refuse to use terminfo/termcap will spew whatever xterm-like escapes they hardcode at tmux/screen, which then uses terminfo/termcap to translate to your actual terminal.
Post reply on HN