Finding the Art in Code
Tags: webdev, art, beginners, writing
Published: 2019-03-13 07:34:41

---
title: Finding the Art in Code
published: true
tags: webdev, art, beginners, writing
---

![Alt text of image](https://thepracticaldev.s3.amazonaws.com/i/1rnl3n35usnienq4xc75.jpg)

To begin I wanted to give a brief introduction to who I am. My name is Matthew Shin and I reside in Seattle, Washington. I am a recent graduate from the University of Washington and am currently a software engineering student at Flatiron School.

For my first blog post, I wanted to write about my experiences with learning to code as someone who comes from an art background. When I graduated from college with a degree in drawing and painting, like many people in my position, I didn’t really know where to take my career. After some deep reflection with myself and family, I decided that it wasn’t necessarily the right time to pursue a career in the arts just yet. Although making that decision was definitely hard, I was optimistic about what was to come next.

This is where my journey into coding began. A couple of my friends suggested learning it, so I decided to try it out. And to be completely honest, I was very skeptical at first. Most people would never associate coding and painting together, including myself. Not only was it intimidating for me to start learning about something completely new, but my initial thoughts about not being able to apply and utilize the knowledge that I already had became a source for additional pressure. However, after starting my time at Flatiron and being exposed to coding everyday, I realized that coding and painting are actually similar in many ways.

One reason that I fell in love with art is that there are many ways to do a single thing. Take for example the task of drawing a face. One person could start with the eyes while another starts with the head’s shape, but the end product in this case is always a face; no matter how different it looks from one another. Some may argue that there is a “correct” way to draw a face, but in the end, the artist is the one in control of how they want to come up with a solution.

![Alt text of image](https://thepracticaldev.s3.amazonaws.com/i/zgk1jhum61ny1tzlvq8j.jpg)

Coding is similar in this aspect of having various ways to go about solving a specific problem. Two individuals could be be given the task of creating an application that does the exact same thing, but their codes can (and probably will) look completely different.

```ruby
array = [1, 2, 3]

def square(array)
  new_array = []
  array.each do |x|
    new array << (x ** 2)
  end
  new_array
end

def square(array)
  array.map do |x|
    x ** 2
  end 
end
```

The above Ruby code is just a very simple and straightforward way to illustrate this idea that an individual can complete the same task with different lines of code. In this example, there are two methods that take in an argument of an array, written differently, but both squaring each number in the array and returning them.

Realizing that I was still able to exercise my creativity while coding by having the freedom to solve problems in my own way definitely drew me into it the same way that creating art did. Coding being able to stimulate creativity became even more apparent as I started to work on labs/projects that required greater critical thinking and problem solving.

Another similarity between coding and painting/drawing that I found interesting was the whole process behind actually creating something. I was able to see this connection by working through my first big project at Flatiron, which was to make a command line database application using Ruby. (I won’t go into depth about this particular project, but feel free to visit https://github.com/njenga-kariuki/module-one-final-project-guidelines-seattle-web-career-021819 if interested in seeing what it was.)

A piece of advice from one of my art instructors in college that really stuck with me when considering starting a new project was to think about artworks as an accumulation of smaller shapes and forms. You don’t immediately paint a masterpiece, you slowly build up to it. These smaller things create the foundation and eventually come together to produce the final result. An easy way to visualize this is through the characters in “The Simpsons”.

![Alt text of image](https://thepracticaldev.s3.amazonaws.com/i/hrh0o1wc8hvqqg3jrzqg.jpg)

Looking at the above image, individual shapes are first drawn and put together to create what we see as Bart Simpson.

The process behind creating a command line application was very similar to the steps I would have taken for a painting. Like starting a new painting on blank canvas, this project started with a text editor devoid of any lines of code. Beginning with the conceptualization of an idea to slowly building up the program with lines of code, I began to consider coding as an art form of its own. For me personally, I also think that there is something aesthetic about lines of code when it is presented in front of you.

![Alt text of image](https://thepracticaldev.s3.amazonaws.com/i/ax9hh2wfxeq5k620aac1.png)

If I had to literally compare making a program to making a painting, each individual line of code is like a brush stroke or line drawn. The individual files that consist of these lines of code are like the shapes and forms created by those very strokes or lines. All the files then come together to create the entire program much like the shapes and forms do in a painting. And when all is said and done, the feeling of gratification you get from finishing a coding project you spent hours on is exactly the same as when you finish a painting.