Viznut

It seems that the BASIC's of yesteryear still have a lot to teach us.

My favourite example is the annual BASIC 10 liner competition:

https://basic10liner.com/

Basically, folks compete to write the best, most interesting, most inspiring 10 lines of BASIC code imaginable .. and ooh boy, has there ever been some truly amazing stuff! A dynamically generated dungeon crawler, a full implementation of lunar lander, countless arcade-style games, an implementation of Brainfuck .. the list goes on and on .. all in just 10 LINES OF BASIC!

Another source of BASIC inspiration, I find, is in the synthesis one-liner scene - which of course, is dominated by the C64 for its synth goodness, but there are other examples out there where, in just a single line of code, entire techno and other electronic-music tracks are generated, on the fly, by ye' olde 8-bit computer of choice (C64, mostly, though..) The bytebeat techniques in use by some synth-one-liner hackers seem to be continually producing extraordinary results.

For example:

https://replicate.com/andreasjansson/synth-one-liner/readme

.. and a good treatise on the various techniques:

https://countercomplex.blogspot.com/2011/10/algorithmic-symphonies-from-one-line-of.html

I think there is a lot of value in learning BASIC using these kinds of techniques in this day and age. I know for sure I'd struggle to have a full Lunar Lander or Asteroids implementation of just 10 lines of javascript, if that is even feasible .. but seeing so…

Small modules are easy to reason about

Yes they are, in the same way that a book in which every page consists of a single word is easier to understand than one with more content per page.

By focusing on the small-scale complexity to such an extreme, you've managed to make the whole system much harder to understand, and understanding the big picture is vital to things like debugging and making systems which are efficient overall.

IMHO this hyperabstraction and hypermodularisation (I just made these terms up, but I think they should be used more) is a symptom of a community that has mainly abandoned real thought and replaced it with dogmatic cargo-cult adherence to "best practices" which they think will somehow magically make their software awesome if taken to extremes. It's easy to see how advice like "keep functions short" and "don't implement anything yourself" could lead to such absurdity when taken to their logical conclusions. The same mentality with "more OOP is better" is what lead to Enterprise Java.

Related article that explains this phenomenon in more detail:
http://countercomplex.blogspot.ca/2014/08/the-resource-leak-bug-of-our.html

I think the theory behind this is a great deal more interesting than that video lets on. The idea started out as simple C programs piping characters to a UNIX audio device. But it's grown since then, now there's a web page that lets you create audio with Javascript expressions[1] (one of my favorite tracks from this scene was generated that way[2]).

There's some good blog posts about the origins of this[3], and music theory behind it[4]; both of which will go into more detail than I'd care to for a HN comment[3].

[1] http://wurstcaptures.untergrund.net/music/

[2] http://www.youtube.com/watch?feature=player_detailpage&v=tCRPUv8V22o#t=314s (5m 13s)

[3] http://countercomplex.blogspot.co.uk/2011/10/algorithmic-symphonies-from-one-line-of.html

[4] http://countercomplex.blogspot.co.uk/2011/10/some-deep-analysis-of-one-line-music.html

I've seen these floating around on YouTube, so you might have some luck searching there (be aware of your volume settings when playing these!)

- https://youtu.be/L9KLnN0GczI

- https://youtu.be/GtQdIYUtAHg

And a longer write-up on the background from the second video:

- http://countercomplex.blogspot.com/2011/10/some-deep-analysis-of-one-line-music.html

- http://countercomplex.blogspot.com/2011/10/algorithmic-symphonies-from-one-line-of.html

- https://youtu.be/pFgui9uGmr4

See these past submissions - https://hn.algolia.com/?q=bytebeat

And these longer explanations on what bytebeat is:

- http://canonical.org/~kragen/bytebeat/

- https://countercomplex.blogspot.com/2011/10/algorithmic-symphonies-from-one-line-of.html

- https://stellartux.github.io/websynth/guide.html