Abstract Art, Technically Speaking

Abstract art explores the relationships of form to create a composition that seems a step or two away from reality. It requires you to have a basic understanding of the underlying structure and to use your imagination to visualize the final form. The first time that the idea of abstraction clicked for me was back in the old days of high school art class. We did an exercise where we had to draw a figure model using only three lines. Of course, at the time, this was a hilarious exercise because everyone in the class got a chance to stand up on the table and show off a ridiculous pose. However, it proved to be a meaningful example of just how powerful abstraction can be. Humans are complex creatures both physically and mentally and yet, with just three simple lines, you could see beyond the structure and visualize the model posing.

Yellow-Red-Blue, Wassily Kandinsky, 1925

Take a long hard look at this Kandinsky painting above. What is this painting supposed to be? Maybe the left is showing a sun setting over a can of hair spray, or maybe its a face looking out into the distance. Maybe the right is a ribbon and some shark fins poking out of the surface of the ocean or maybe you saw something completely different that I couldn’t even imagine. The beauty about abstract art is that all of those are correct. Your mind is making associations based on the structures and forms that you are familiar with. I love swimming in the ocean so I immediately associate those triangles on the right with shark fins piercing through the water. Abstract art is all about interpretation and being able to visualize beyond what’s right in front of you. Kandinsky created a painting composed of basic form structures that seem a step away from reality because of their “unfinished” nature. This forces the viewer to transform it into reality in their minds. Coding is exactly the same.

Similar to painting, coding is a combination of structure and creativity. Abstract code, like art, requires a basic understanding of coding structure and some imagination. This can become powerful because the more you abstract your basic code structure, the more dynamic your application becomes. Furthermore, the more dynamic you make your application, the less prone it becomes to human errors, and let’s be real, humans make a LOT of errors.

Since pictures are everything, I’m going to show you what I’m talking about. Let’s say we’re making an application that lists all of the possible methods of public transportation in New York City. The most non-abstract way to create this would be to simply type up a list and print it. After a quick Google search, we might come up with something like this:

[left] Basic Ruby Method, Corinne Kelly, 2017 [right] Girl With a Pearl Earring, Johannes Vermeer, 1665

Just by looking at this code, even a non-techie can tell that it will print out a list and know all of the elements of the list. This is because we know exactly what the structure of a list looks like. There’s usually a title on the top followed by rows of information. When we look at this code we don’t have to imagine anything because this is clearly a list. Similarly, in Vermeer’s famous “Girl With a Pearl Earring” even someone with no imagination can immediately tell that this is supposed to be a portrait of a girl with a pearl earring.

Although this might work for right now, it’s not very practical. What if I accidentally copied the list wrong from google and forgot some important items, like the Ferry or the LIRR? What if something new gets invented like self driving spaceship transporters? What if someone moves from Portland tomorrow and convinces everyone to ride unicycles and all modes of public transportation become obsolete? Well, then this list would become utterly useless. Since we obviously can’t predict the future and can’t prevent humans from making errors, wouldn’t it be better if something other than a human created a list that could keep up with the times?

[left] Abstract Ruby Method, Corinne Kelly, 2017 [right] Yellow-Red-Blue, Wassily Kandinsky, 1925

Abstraction in code is all about simplifying and creating dynamic objects. Like Kandinsky’s abstract painting above, our code works better if we remove it from reality a bit and break it down to a more abstract form. In this case, reality would be our final product, an accurate list of transportation methods for NYC. Instead of putting the list in final form directly inside our code, we could create a more dynamic method that parses API data to produce a more accurate list. When you look at the structure of the code you will not see a list, but if you understand the basic structure of this code then you can use your imagination to visualize the list that it will produce. Similar to the visuals you created in your head when looking at the Kandinsky painting, the details of the list will not be apparent because we don’t know exactly what is listed in the mta_api hash, but we know with certainty that this will print a numbered list.

Abstract painting and abstract coding might require a bit more thought and creativity to produce but in the end, it’s worth the journey.