
The Way Houyhnhnms Compute (2015) - panic
http://ngnghm.github.io/blog/2015/08/02/chapter-1-the-way-houyhnhnms-compute/
======
lotyrin
This sense of simplicity is certainly lacking.

Seems like you should be able to say "new values of y are entered by users, x
is the sum of all y, z = 2x, every night text me the value of z" and compile
that to a cross-platform native UI + cross-cloud api gateway + serverless
function + persistence layer in a few lines of code as an afternoon exercise
in an elementary school class, and such a runtime could extend its use cases
to a decent portion of the CRUD much of industry toils away at, without having
to itself become essentially complex.

There's lots of assumptions in our systems that are counter to simplicity, or
simply counterintuitive. People expect things to be declarative (a = 0; b = 2;
a = b; What? But a can't be 2 and 0...) persistent and consistent by default
(what do you mean I have to save to disk and re-load it every time, why do two
people both think they have this same table reserved, wtf is a partition),
replicated by default (why can't my database be like google sheets... wait,
why can't it BE a google sheet?), safe by default (why is this negative when
it only ever goes up... overflow? wtf, why is that even allowed!? Wait, there
are special things called bignums... why isn't that just every number all the
time?) etc.

It seems lots of production software for humans that operates on human
timescales can take the performance hit that these more ergonomic set of
assumptions would require and many would be better off for it.

They could be the initial set of assumptions in an academic setting so you
don't have to trip over the machine all the time in the early stages. You
could then pare back one at a time with exploration of the benefits of the
trade-off and cases where they are necessities (e.g. higher txn rates than a
synchronous multi-master datastore could handle) so that instruction in the
realities of computing come in bite-size and are paired with ample motivation
to get over each hurdle (instead of upfront pain followed by latent payoff).

Without scraping the sharp edges of implementation detail, we could focus on
design of these things -- both in terms of considering performance or
maintenance headaches and in terms of applicability to real-world usage -- so
there'd be more commonality between the fiddler who means well "non-coder"
type who has unmaintainable SFDC schema or pet spreadsheet hell messes and the
annoyed reality won't succumb to his ideal "software engineer" type banging
out strongly typed highly normalized models in their ivory tower with no
sympathy for end user (and yet also nothing to which they can apply their
proud knowledge of algorithms or data structures or machine sympathy).

------
pietroglyph
This is an entire (delightful) series:
[https://ngnghm.github.io/index.html](https://ngnghm.github.io/index.html)

I have often wondered how a hypothetical alien would perceive our computer
systems... It's wonderful to see someone has thought about it too (and they
made it fun to read about!)

------
madeofmeat
Simple, they just stamp their hooves the right number of times.

