Houyhnhnm Computing | Hacker News Reader

Houyhnhnm Computing

ngnghm.github.io

73 points_qc3o22 comments

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)

...or at least to get away from the techniques of the Yahoo.

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).

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.

I agree.

There is a price to be paid for tightly coupled system.

I forgot but there was this good book on mathematics that paul graham recommended.

That book talks about the fact that every 100 years in mathematics there is an explosion of innovation and then at the end of a period there is integration.

Having diversity is how things improve - its also the basic law of physics - entropy.

By creating chaos we learn more about how to do things better, either it be software or mathematics. So to those software craftsman who are complaining about diversity - grow up, this is how all of science works.

To draw this out further: our expectation of ultimate transience, which has resulted in enormous numbers of files being stranded on now-unreadable media or simply obliterated into thermal noise when someone kicked the plug, has an upside: it allows us to be wrong. We can go down blind alleys like Microsoft Bob. We can afford to throw a hundred different approaches at a problem and see which one sticks. Even if it sticks for a dumb reason like "everyone already uses Word", we can gradually improve what stuck, or propose new approaches like Google Docs. Or we can toss it all and move to tablets.

There was an OS that had a similar component oriented model to what was being imagined here, and that was Apple Taligent. It was built around the component embedding model "OpenDoc" and had editors for types of content not types of file. It turned into a never-arriving death march, and I have a feeling that part of the problem is that in the presence of diversity of choice, the component model sucks. How can LyX and Microsoft word operate as components, and share data, when their assumptions are so radically different? The answer is that they can't, and that component data will live in little silos unless flattened down to a deliberately weakened structure like plain text cut and paste. Unless you have One Twue Text Editor. And One Twue Pixel Editor. And so forth. It's an ecosystem that can only tolerate tyranny. (Microsoft's tiles UI suffers the same problem. Looks pretty and makes sense only on a phone where they have all the programs under their thumb.)

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.

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.

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.

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

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 http://www.meetup.com/LispNYC/events/224215944/

Looking forward to the chapter on Mmrnmhrm Monad Transformers.

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

The discourse reminds me of Urbit:

https://github.com/urbit/urbit

Alien virtual machines and that kind of thing.

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).

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

I'm starting to suspect they have the same people behind them.

Either that or Loper OS http://www.loper-os.org/

I have a chapter in preparation that addresses the comparison with Urbit.

So this is about something better than Yahoo?

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

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

vaporware computing

Yes, but the interesting part is wetware metaprogramming.

Reply on news.ycombinator.com