Six works of Computer Science-Fiction (2015)(blog.fogus.me) |
Six works of Computer Science-Fiction (2015)(blog.fogus.me) |
It is like a discovering a new programming paradigm. Something new and different, not a Lisp, not a Datalog, weirdly distributed, with interesting properties, but powerful. There are adjacent things, BLOOM project and Eve language seems to have discovered something simmilar, and Edward Kmett working on his new language is using propagators quite heavily.
https://pdfs.semanticscholar.org/755c/48fd10aa303497ef849977...
Sci-fy to go with it: probably Ted Chiangs Stories of your Life (or its movie adaptation Arrival)
Out of the tarpit
I thing this is a paper that might have lead to Clojure, React, Elm, e.t.c ... but not really, a weird parallel reality where we really like reactive relational databases.
In terms of Knuth-style literate programming, Org Mode in Emacs, with its Org Babel feature, is a very good tool for this. It's an outliner with rich markup, and where you'd ordinarily insert a code block, in Org Mode, you can also execute it (works with any language you've configured Emacs to connect to) and feed the results to further code blocks. So it works like a computational notebook. You can also tangle the blocks to produce a separate source file, the Knuth way. One common application I've seen is making literate Emacs configuration - people prepare the minimum necessary to set up Org Babel, and then tangle the proper (often large) config from an .org file, where it's written in literate style.
As for my own experience, I occasionally try literate programming on small things, and so far - outside using org mode as a Jupyter alternative - I didn't feel more productive with it. I often flesh out the idea of a solution while writing it (I alternate between coding/recoding and design phases), and literate programming adds extra work - refactoring code means also refactoring the surrounding prose. On top of that, the narrative structure seems to interfere a bit with program's own architecture. I know it shouldn't (thanks to the way tangling works), but it somehow does in my head.
Writing literature is a solo endeavour.
Modern programming is more like writing scientific literature, where multiple persons collaborate, and reading and understanding earlier work and maintaining a correct set of links to such works is half the work, if not more.
That, I think, is why literate programming doesn’t quite work. It works for Mathematica notebooks, iPython notebooks and the like, but not for larger works.
The hard part with such tools is version control.
Which reminds me its time to view his annual emeritus youtube lecture he gives in December. Still working.
"SICP is an exploration of programming free-love. Indeed, the tone, examples, references, and hearken to a programming life that if true, would be an absolute blast to live in."
It's a bit difficult to define this genre (but how can we not?). I found the K&R personally mind-blowing when I read it (and someone in the comments suggests it), but I'm not sure it qualifies. Many classic works strike me as "computer science-fiction," but not all classics of computer science are.
There's something fanciful and idealistic about these particular works -- something about their tone that seems vaguely utopian or futuristic.
Michael Fogus is a fine writer, though his own books seem strikingly down-to-earth. Really, I think he should expand this into a full-blown essay.
I think there are some ‘accidents’ of technological choices that have had unfortunate consequences for the modern industry. We could have done with something better than JavaScript for example, but these aren’t ‘paradigm’ issue (I tried avoiding that word, but there it is). By and large the direction the industry has gone has been chosen for sound practical reasons.
In the end, none of the alternate history directions the industry could have taken are off the table forever. If Oberon or Smalltalk had been a superior way to build software, there’s nothing stopping someone taking their evergreen fundamentals and building them into a modern system. If that doesn’t happen, again there are probably reasons for that.
For me the most magical texts I have ever read were TAPL by Pierce, or the Lean Theorem Prover (tutorial/guide?) [1].
Just from a software standpoint, Lean seems like one of the most magical things ever built. For something that is built by mathematically-oriented programmers for pure mathematicians, it is /extremely/ well designed. So much thought has seemed to go into the user experience; it’s rest a joy to use.
Every chapter in that guide, has blown my mind more than the previous. It is super accessible as well to anyone with the math background found in any undergrad CS program.
[1]: https://leanprover.github.io/theorem_proving_in_lean/introdu...
It's pretty good. Centers on AI (but isn't a cliche Terminator-like scenario) and gets into very philosophical territory by the end, and has the pacing/tone of an espionage thriller.
Like a treasure hunt every time I enter.
[1] At this time 4 of the 7 top-level comments and all the active discussions are about sci-fi, not what the article describes
https://highexistence.com/the-last-answer-short-story/
There is another story I like about a planet of high-IQ beings noticing patterns in stars blinking (like binary) and going into suspended animation to observe the data over extended periods of years, but I can't remember the name of it or the author.
I think Asimov said often people would ask him “What’s that story called where ...” and he’d cut them off and answer “The Last Question”.
Every chapter begins with a quote from a Markov chain trained on the King James Bible, SICP, and ESR. For example:
> It is good practice to have your program poke around at runtime and see if it can be used to give a light unto the Gentiles.
The first chapter begins
> The apocalypse began in a cubicle.
> ... Upon the floor was a chair and upon the chair was me. My name is Aaron Smith-Teller and I am twenty-two years old. I was fiddling with a rubber band and counting the minutes until my next break and seeking the hidden transcendent Names of God.
> “AR-ASH-KON-CHEL-NA-VAN-TSIR,” I chanted.
> That wasn’t a hidden transcendent Name of God. That wasn’t surprising. During my six months at Countenance I must have spoken five hundred thousand of these words. Each had taken about five seconds, earned me about two cents, and cost a small portion of my dignity. None of them had been hidden transcendent Names of God.
I found both the math and the vignettes about life in the USSR to be fascinating.
I read this after hearing many good things about it, especially about how well thought out the science in it was.
While the science was solid as far as speculative fiction action-thriller science goes, I felt like the action scenes were being choreographed by a six year old who had read too many comics, in that every single event felt like it was a deus ex machina, only to be matched by a bigger and more catastrophic deus ex machina. Y'know, like "the car shot lasers! until it was blown up! but it blew up into two motorcyles! that shot ninja stars!". The aid to my suspension of disbelief I got from the "good science" being plausible fell apart at how implausible the actual chain of events were.
It was a page-turner, but ultimately I left the book feeling a little exhausted by it all. Would highly recommend to anyone who wants to have the equivalent literary experience of drinking a red bull.
My memory now is that reads like a script for an action movie.
The "actual reasons" could just be laziness, a bad industry, valid then but not relevant anymore, and several other things other than "eternally valid".
So just because those ideas and implementations where "relegated to" the margins, doesn't mean they should remain there.
Except if we're all too happy with the current state of the computing industry and developer practices. Are we?
>By and large the direction the industry has gone has been chosen for sound practical reasons.
Yeah, no. Some things caught on for practical reasons (e.g. C was portable, free, fast enough in a constrained era. But even C could have easily been bettered with a language more or less the same just with bounds checking, without pointer arithmetic, without nulls, with a string type, etc, and we'd be 200% better).
Others just caught because big companies pushed them with tons of marketing money (e.g. Java - at the moment Smalltalk was big in the same space, support and IDEs from IBM, etc). Others by BS CEO decision (e.g. Javascript not being a light-scheme as originally intended, because management wanted to latch onto the Java bandwagon). Others because of slow progress (slow uptake of innovation, even if it can run perfectly well in the hardware of the time), others without any real reason (it's mostly what's taught at schools, what catches on as fad, etc).
It took 60 years (in fact, it's still ongoing) for programming tools and concepts we had even as back as Lisp to make with first class support into mainstream programming languages (closures, immutability, map/fold, and so on). CSP took until Golang to catch on in the mainstream... Those things were "in the margin" all this time...
It is an excellent and hilarious read nonetheless. One of the best web serials I have read.
https://urbigenous.net/library/nine_billion_names_of_god.htm...
I don't actually know that UNSONG is literally Answer To Job only long (excellent) fiction, but I don't know it isn't ;)
would be my nominations
A good example is the recent discussion on the amyloid plaque "cabal" [0]. The comments confirm, but also attenuate the article, and together with my own experiences in science I feel confident to forward the article. Comments and discussions such as [1] are clearly from people deeply involved in the field or at least from very knowledgeable people, and they nicely balance the often polarizing articles.
Imho the HN algorithms seem to work very well in getting quality content to the top, given time (an article may well be gone from the home page by then).
It also helps that I think out of all of the reads mentioned on this comment thread so far, Unsong is definitely my favourite of the lot.
Replies need to connect to the comment they reply to. That's not the issue here.
Observable - that's a true joy if you want fast feedback and interactivity. It's as fast as your browser, since your notebook is entirely client-side executed JavaScript. It's an order of magnitude better option than regular notebooks if you want to do some exploratory or scientific visualization. It's main drawback: JavaScript. That's what you're limited to. So forget about your favorite Python or R libraries (at least without dark hacking magic).