bboard hyperpithole gate
(DIR) Menu
(DIR) Section <GOPHER>
(DIR) Forward
(DIR) Backward
Thread[.post]: 36.5
TACKER: cross (Dan Cross)
SUBJECT: .. How you were using the Internet in the 90's?
DATE: 24-Jan-22 15:14:12
HOST: sverige
In many respects, use of tools like "gopher" back in those days
was a matter of necessity rather than preference. The reality
was that we didn't have much of an alternative: the web existed,
but hadn't won yet, and most people were still using slow dialup
connections to access the 'net. Plain text was just more
efficient when you were dialed into a timesharing system. Once
access speeds got faster and we got more powerful workstations
that gave a richer user experience, many of those tools were
quickly left behind.
Gopher in particular never made much of an impression on me. It
was marginally useful for accessing specific information, but
USENET as both a collaborative space and directory of pointers
to other resources elsewhere on the net, coupled with telnet and
FTP were much more broadly useful. The "archie" protocol was
similarly useful for finding things across anonymous FTP sites.
I confess that the rise of the web struck me as odd; it seemed
like a fancy gimmick, but the protocol was terribly inefficient
at the time and the markup language anemic if you were used to
tools like troff and TeX/LaTeX for typesetting documents. Much
of this criticism remains generally true; math markup, for
instance, is still way behind (though tools like MathJAX and
[ SCROLL (F)ORWARD, (B)ACKWARD - (Q)UIT ] FORWARD
KaTeX go a long way toward briding the gap).
This resurgence of interest in Gopher is just baffling, though.
What's the point? Modern HTTP is a much better protocol in
every way, and if all you want is a text-based experience (which
I can sympathize with) that's achievable using a text-based
browser and really light-weight markup. If you're going to run
Gopher, you're almost certainly already running a server of
some kind somewhere; why not run an HTTP server? It doesn't
_have_ to serve ads and oodles of JavaScript and tracking
cookies and all the rest of the goo found on the "modern" web;
it can just as easily emit text. Suppose one used a static
site-generator analogous to Hugo to convert markdown to lightly
formatted HTML (e.g., just <a>, <p> and <br> tags or something).
One could even turn a subdirectory tree of such files into
basically what a gopher server gives you. You could even have
a light-weight HTTP server that dynamically converted a
light-weight markup into light-weight HTML, completely
replicating the Gopher experience but without the inherent
Gopher limitations.
I suspect a lot of energy around gopher these days comes from
two places: a) a nostalgic desire for something lighter-weight
than the modern web, and b) a desire to be gratuitously
different because it's "cool", in the same way hipsters were all
using Polaroid cameras 15 years ago. (a) is certainly laudable,
but based on a false dichotomy: web2 is too intrusive and
inefficient, therefore, HTML+HTTP should be discarded. I can
[ SCROLL (F)ORWARD, (B)ACKWARD - (Q)UIT ] FORWARD
agree with the former, but the latter simply does not follow.
HTTP _these days_ is fine, and using it brings network effects
(e.g., we have oodles of infrastructure to support it) and HTML
can be nearly as light as you want it to be, and we still have
text-mode browsers (like lynx, w3m, links/elinks, whatever). We
can escape web2 (and don't get me started on web3...) without
throwing out the useful bits of the WWW. As for (b) well...just
remember that polaroid cameras don't take high-quality
photographs.
Bottom line: protocols change over time. That's good. We
mostly gave up on telnet, plain-text FTP, rsh, rlogin, etc. In
those cases, the underlying environment changed enough that
those earlier protocols stopped making a lot of sense (hello,
packet sniffers). Gopher similarly got left behind in the 90's
for a reason. Reviving it these days for curiousity and
nostalgia is not a priori bad (after all, people collect stamps
for fun...), but it is also not terribly useful. The 80s and
90s sure didn't feel like a golden age at the time; we used
those tools and protocols just because they were what we had
available. To the extent that it _was_ a golden age, it was
mostly because the people and the music were cool, less the
technology those people used.
(PS: I turned down a machine yesterday that had been running for
almost 30 years. It was networked with another machine, used
NFS to share data, Kerberos for networked authentication, etc.
This made me personally sad as it's just another reminder that
[ SCROLL (F)ORWARD, (B)ACKWARD - (Q)UIT ] FORWARD
mostly gave up on telnet, plain-text FTP, rsh, rlogin, etc. In
those cases, the underlying environment changed enough that
those earlier protocols stopped making a lot of sense (hello,
packet sniffers). Gopher similarly got left behind in the 90's
for a reason. Reviving it these days for curiousity and
nostalgia is not a priori bad (after all, people collect stamps
for fun...), but it is also not terribly useful. The 80s and
90s sure didn't feel like a golden age at the time; we used
those tools and protocols just because they were what we had
available. To the extent that it _was_ a golden age, it was
mostly because the people and the music were cool, less the
technology those people used.
(PS: I turned down a machine yesterday that had been running for
almost 30 years. It was networked with another machine, used
NFS to share data, Kerberos for networked authentication, etc.
This made me personally sad as it's just another reminder that
the way we _use_ computers, and the communities we form around
that use, are not particularly durable. But the "machine" had
long since transcended its original physical form and was on a
VPS and just wasn't used enough to justify its continued
existence. This is cheaper, though, and we kept one computer
for people to log into if they want. The point is, don't pine
for the nostalgia of lost "golden-ages": those existed in
specific places and points and time, most of which are very
different now. Trying to go back is usually an exercise in
frustration.)
<GOPHER.36.5/18>(142)[ <ENTER> follow thread, (R)EPLY, (F)LAG or (Q)UIT ]