
Houyhnhnm Computing - _qc3o
https://ngnghm.github.io/index.html
======
stepvhen
The Houynhnms, from Jonathan Swift's "Gulliver's Travels", were a race of
intelligent horses, whose entire society was based solely on reason. I imagine
the goal here is to propose coldly reasonable concepts in computing. (And I
offer this explanation because the website itself, including the about
section, is done in a literary style, making it difficult to quickly scan and
summarize for those of us who haven't read or don't remember Gulliver's
Travels when the book was assigned in high school)

~~~
spb
I think the point is not so much to present a _purely logical_ viewpoint as it
is to present a _culturally removed_ viewpoint that _still comprehends
engineering fundamentals_ , since any hypothetical _human on Earth_ with such
a comprehension would have to be already familiar with the status quo.

See, for instance, the first example, where the C programming environment is
presented as "simple", but then acknowledged to be actually enormously
complex, due to the many specific platform assumptions presupposing it (such
as the abstraction of files and directories, which every human developer today
comprehends as practically a law of nature).

------
JulianMorrison
I have a feeling this sort of thing that looks like heaven in the present,
would look like hell if we'd inherited it from the past. Everything has
versioning built in - great, Subversion is wired into the One Worldwide OS.
You want to propose Git as an improvement? Okay, but it's gonna require a UN
resolution. And the GUI is Xerox Alto. It would be far too complicated to
rework everything for an improvement there.

~~~
maxander
Since we're discussing the notional programming practices of a race of
sentient equiinoids, I might advance a counterpoint; the reason we're served
so well by transience is that humanity has spent its 50-odd years of serious
computing history mostly getting things wrong, but that shouldn't disabuse us
of the notion that things can be gotten _right_. There's nothing inherent
about computing (or technology in general) that says that there isn't (say) an
ideal OS kernel design, such that once it was written and widely adopted no
one would have reason to replace it. The same logic might need to be re-
implemented for new hardware, new interfaces and capabilities might need to be
placed on top of it, etc, but Houyhnhnm systems seem to allow for that sort of
cosmetic change (and we might expect graceful extensibility to be a quality
the perfect kernel would have.) What that ideal kernel would be is beyond our
scientific and engineering knowledge, but give humanity a break- we've been at
this for less than a century.

The author starts out the first chapter by explicitly comparing the
development of the human computing ecosystem to evolution, and the entire
thrust of the series seems to be the nature of systems designed by creatures
capable of seeing the Rational Way To Do Things and unencumbered by our
historical human foibles. Which is a developer's wish-fulfillment fantasy, to
be sure, but science fiction about ideal worlds can help to reorient our
priorities on this messy planet.

~~~
legulere
Sure there are ideal designs, but only for certain requirements. Operating
systems are a good example for changing requirements: Operating Systems were
seen as a field where everything was solved until multi-core came along. Today
we have the situation that instead of protecting the system from users and
users from each other we have to protect the user (singular!) from malicious
programs.

~~~
maxander
I suspect a Houyhnhnm would reply that the very concept of the requirements
changing for a set thing like an "operating system" is a category error- the
_idea_ of an operating system is defined (by a perfectly rational Houyhnhnm)
as a given set of requirements. Change those, and you're now talking about a
different kind of thing.

We can talk about plenty of things that are (in human-speak) part of the
requirements for OSes now that, X years ago, weren't. But (a Houyhnhnm might
say) there's an exhaustive set of all things that an OS ( _qua_ an OS) should
do, and once you have that, you have an OS that will stand the test of time
(essentially) unchanged. We hadn't (and probably still haven't) enumerated and
implemented all of these capabilities simply because our primitive computing
technology base is still coming of age.

Really, to a computer scientist in 1960, an OS was probably just something
that made his mainframe _go_ so that he could do more interesting things. It
would take a optimally-rational equine being to sit down at that stage and
work out exactly, in an ideal sense applicable to all feasible computing
devices, what an OS should be. And its still the case, since I doubt the
architects of modern OSes give much thought to quantum computing interfaces or
nanite-cloud networking or whatever. But adopting the Houyhnhnm-ist manner of
thinking about OSes (or more humble applications) as implementations abstract
ideal entities rather than bits of machinery might make it easier when,
however long down the road, someone is trying to use our work for something
that we hadn't foreseen.

------
_mhr_
This appears to be connected to François-René Rideau's TUNES project
([http://ngnghm.github.io/talks/cc-
lc2016.pdf](http://ngnghm.github.io/talks/cc-lc2016.pdf)). These slides are
probably worthy of a submission themselves.

~~~
farray
The slides are meant to support a talk. What will be more worthy of
publication will be the video for the talk, when it's edited and uploaded.

In the meantime, there is a bad recording of an earlier take on the same ideas
from LispNYC. The talk at LambdaConf was definitely better delivered, though.
[https://vimeo.com/155517248](https://vimeo.com/155517248)
[http://www.meetup.com/LispNYC/events/224215944/](http://www.meetup.com/LispNYC/events/224215944/)

------
harveywi
Looking forward to the chapter on Mmrnmhrm Monad Transformers.

[1] [http://wiki.uqm.stack.nl/X-Form](http://wiki.uqm.stack.nl/X-Form)

------
guard-of-terra
The discourse reminds me of Urbit:

[https://github.com/urbit/urbit](https://github.com/urbit/urbit)

Alien virtual machines and that kind of thing.

~~~
davidgerard
Urbit was my first thought too, at least in the ambition of starting afresh
with alien assumptions. I can understand this a bit better and it doesn't
trigger my "this is all batshit insane" detector. Also, decrement probably
isn't O(n).

~~~
setra
decrement is not O(n) in practice just as addition is not horribly slow when
defined in idris

------
CurtMonash
So this is about something better than Yahoo?

------
ashitlerferad
Started reading from Chapter 1. This is beginning to sound like HP's "The
Machine".

------
wrong_variable
I am not sure how serious this is or is it just a joke.

------
lil1729
vaporware computing

~~~
farray
Yes, but the interesting part is wetware metaprogramming.

