Reading Reflection Chapter 4
I found this week’s reading to be particularly relevant, as I continue to struggle with wrapping up the audio visualizer assignment. I wanted to touch on and explore the principles 4.10 and 4.11, which are “programmability is both blessing and curse”, and “there is an art to programming”, and what ways we can approach the idea of an artfully constructed program.
When thinking about the “art to programming”, my first thought is of the idea of “beautiful code”. It’s something that is often repeated in Stanford’s classes, which defines code as “beautiful” if it is efficient and easily readable. Do we consider this beauty to be part of a piece of design’s artfulness? Say you had two copies of the same program that functioned completely the same, but one was written in barely understandable spaghetti code while the other was clean and readable. Would the more readable one have more aesthetic value in some way? Can messy or deliberately obfuscated code be an intentional design choice? Does it even matter if the code is never even shown? One interesting example that I’ve found is in this “donuts code”, which is a piece of C code, shaped into the form of a donut, which generates a 3D animation of a spinning donut!
It’s obvious that the code written to generate the animation is not the most efficient way to do so, and it is nearly impossible to read or understand what is happening at first glance. But I find the way in which the shape of the code mimics the shape of the result to be something fairly meaningful. It’s quite reminiscent of the zipper bag monster we covered in chapter 1! In this case, the “form” of the code has quite literally matched its “functional form”, so to speak.
I found myself questioning Principle 4.10, specifically the portion that read “just because something is programmable doesn’t make it interesting… it’s possible to build the software and procrastinate on the art/product”. But can’t the software itself be considered artful? Take a program like a quine, which is a program that reproduces a copy of itself. It has essentially zero practical use, but that process of self-reproduction feels very similar to the ‘design loops’ we covered in Chapter 3, and is fairly interesting to consider. If something like this which has 0 practical use can still be interesting or meaningful, when can we define a piece of programming as “lacking interest”?