On Tue, Sep 16, 2025 at 6:42 PM sirjofri via 9fans <[email protected]> wrote:
> 16.09.2025 20:05:56 Dan Cross <[email protected]>:
>
> > `drawterm` doesn't really qualify, in the sense that `drawterm` is a
> > program that runs under another, non-Plan 9 operating system. By
> > itself, drawterm can't really do much; one may think of it as a
> > program that emulates just enough of a plan9 terminal and its devices
> > (/dev/draw, mouse, keyboard) so that it can connect to a remote cpu
> > server, where all the actual work is done (including running e.g., the
> > window system). But it doesn't run programs on its own, and there is
> > no such thing as a "standalone drawterm".
>
> In the last few weeks, I was thinking about how hard it would be to build an
> inferno drawterm. That is, implement all the necessary tools to interact with
> a plan 9/9front system in the way we know with (r)cpu and (r)import. That
> would mean that we can use inferno's graphical tools, but also run graphical
> Plan 9 tools on the CPU server, drawing to inferno's devdraw (simplified*). I
> think that would almost qualify as a terminal.
>
> * Obviously, there's more needed than just devdraw. There's all the cons
> stuff, mouse and keyboard, and probably a few other devices.
I'm afraid I haven't paid much attention to Inferno in quite a while,
but the idea seems fine. At one point, Styx was a bit different than
9p (though not excessively so) and the auth protocol was different.
Oh, and the graphics infrastructure used Tk. But those are all
details, and there's no reason things Must be that way: one could
easily imagine compatible devices and protocols across plan9 and
Inferno. One of the neat things about 9p is that it lets you access
resources in a uniform way; the distant end doesn't _have_ to be
running Plan 9 to participate: it just has to speak the protocol(s).
Using Inferno in lieu of drawterm is kind of a neat idea because you
could do Real Work locally, on Inferno, in much the same way you can
on a Plan 9 terminal. You wouldn't need drawterm-for-Inferno, because
Inferno can just do more or less everything that a normal plan 9
terminal would do.
Viz the larger discussion, it may be worth considering the environment
in which plan9 was initially developed. In the late 1980s, you still
had centrally managed computer centers with large timeshared and batch
machines, plus networks of much smaller workstations, PCs, etc. Plan
9 networks might be thought of as a bit of a combination of the two.
Central management gives you economies of scale to provision computing
power, but also to minimize operational and administrative overhead
since you only have to do it in a handful of places, not at every
seat. At the same time, distributed machines empower individual
computing, letting users accomplish tasks without stepping on each
others' toes: I can hammer on MY machine all I want without affecting
my neighbor's work, but at the expense of having to provision,
configure, administer, and backup $n$ different machines, manage
users, software, and storage across them, etc.
Plan 9 was built in a way that threaded the needle between these
models, which came from the recognition of a few emerging trends:
networks were tying everything together, and increasingly, one could
assume that users had access to high-resolution bitmapped graphical
displays (and a mouse and so on). In a plan 9 network, since
terminals don't usually have much in the way of state on them, you get
the operational benefits of centralized administration: all of your
user, network, and storage management can be concentrated in one
logical (if not physical) place. Software management is simple since
it all lives on the centrally-managed file server(s): everything's
installed and upgraded in one place. Similarly, you can provision
significant computing resources that are shared by all users, but only
accessed when needed, in an on-demand fashion: no more fighting
against someone's big numeric simulation job just to run your text
editor because it runs directly on your terminal, which is a real
computer with real graphics (not just a "green screen" 80x24 text
terminal with character addressing) capable of running significant
programs...including ones you write yourself. And since you've got
on-demand access to these large computational resources, your terminal
doesn't need to be sized for your largest job, just the average, thus
lowering per-seat hardware costs.
So you kind of get the best of both worlds: you've got your own
private resources, but you're also plugged into this physically
distributed, but centrally managed, set of shared resources. To me,
that's the real power of the system: you get this wonderfully flexible
and holistic, highly integrated, but still distributed, environment.
Sure, the implementation is nice and simple, and a lot of the sharper
edges of the tools inherited from Unix have been filed down, but I
think that's secondary. The integrated way of accessing shared
resources in a distributed environment is really the key thing.
Inferno is a bit different: it was intended to commercialize the
technology and apply it to embedded devices of various kinds. Think
set-top boxes, "smart" video phones, routers/telephone switches,
firewalls, and so on. But you could also run it as an application on
other OSes, which was not only kinda cool, but could have allowed you
to interact with a plan 9 network, had it been just slightly more
compatible. But in the mid 90s, I don't know that anyone was really
thinking along those lines; it was meant to take advantage of the
underlying distribution model, but that was mostly transparent to, and
hidden from, end users. But hey, it's 2025: have at it!
- Dan C.
------------------------------------------
9fans: 9fans
Permalink:
https://9fans.topicbox.com/groups/9fans/Tf4bb650e9449e4d9-Md446c615cd03e9cc0442a69c
Delivery options: https://9fans.topicbox.com/groups/9fans/subscription
