I wanted to talk about two different styles of programming that you will encounter. Throughout my time learning how to program, I've found myself leaning more towards one than the other. Though there is no 'correct' style to always embrace, I feel it is important to know when to follow each style.

The Conjurer

The Conjurer is the kind of programmer you see in movies. They get to their keyboard, start typing insanely fast, and produce results almost instantaneously. How do they do this?

Make no mistake: The Conjurer isn't a living library of all of the programming language documentation ever written. It's probably not even close to that. Instead, the Conjurer wields a secret weapon: Intuition.

in·tu·i·tion

/ˌint(y)o͞oˈiSH(ə)n/

noun the ability to understand something immediately, without the need for conscious reasoning.

The Conjurer uses their intuition to ignore all the complexity that may arise and only focus on the parts that are important for getting their job done. Their power lies in sifting through all the noise and focusing on the heart of the matter.

To the outside world, this seems like magic.

The Scribe

The Scribe is a scholar. Spending a good amount of time researching documentation, understanding the intricacies of a language/library/framework, and knowing every single edge case before writing a single line of code.

When they write that single line, it is perfect. The Scribe is a living library of all programming knowledge, and has taken it upon themselves to have a deep understanding of topics that interest them. What best describes a Scribe? Mastery.

mas·ter·y

/ˈmast(ə)rē/

noun comprehensive knowledge or skill in a subject or accomplishment.

The Scribe doesn't approach a problem until they absolutely know an answer. It's the patience and discipline that they have internalized that allows them to answer with absolute confidence each and every time.

The Differences

Assume you are a beginning Javascript programmer and you have been given the task to iterate over an array of items, performing some sort of operation on each of them.

As a Scribe, you would begin poring over the Javascript documentation, looking for a way to accomplish this. Knowing the basics of iteration and callbacks, you might produce a function which takes an array and callback, running a for-loop through the array. It may look something like this:

var forEach = function(array, callback){  
    for (var i = 0; i < array.length; i++){
        callback(array[i]);
    }
}

As a Conjurer, you may realize that this must be something that gets done often in Javascript programming, so you would look into the Array prototype object and simply call:

Array.forEach(array, function(elem));  

When I started learning how to program, I really wanted to be a Scribe and master every single thing about Javascript that I touched. That quickly dissipated once I learned about the above mentioned Array.forEach method, which takes an array and a callback which it assigns an element to. The part above that read function(elem) really threw me off for a good amount of time, since I never fully understood exactly where this elem was being taken from.

I think it's important to note that there is a time and place for both styles. While you're learning, it's good to understand what happens under the hood with native functions that you may encounter. However, there will come a time when you do have to let that go and just trust your instinct.