The Key To Accelerating Your Coding Skills

When you learn to code, there is a moment when everything begins to change

At theFirehoseProject we like to call this the Inflection Point of Coding. After this phase, the way you operate as a developer will be dramatically different. It’s the process of becoming self-sufficient in programming to the point where you no longer need any hand-holding. It can be a frustrating experience, but once it’s behind you it is incredibly empowering.

At theFirehoseProject, our goal isn’t just to teach you ruby, how to build web applications, or how to write tests.  Although we do teach these skills, our primary goal is to accelerate students past the inflection point so they are able to solve any problem they encounter, regardless of what it is.  We believe that this process of teaching how to problem-solve on your own is an invaluable skill that will take you much further than simply learning how to build some apps.

The Tutorial Phase (3-8 weeks of serious coding)

When you start out, there’s a lot of information that you don’t know yet.  This information is called Domain Specific Knowledge.  An example would be how to write a loop in ruby or how to extract something from a database using Ruby on Rails. Domain Specific Knowledge encompasses the specific protocols in a certain programming environment.

The first step to becoming a self-sufficient developer is learning how to do specific tasks.  Once you master how to do certain tasks, the broad strokes of how the pieces fit together start to become apparent.  Over time you’ll start to recognize patterns, and eventually things that initially seemed confusing and foreign will become second nature.

For students starting out, the most important skill to acquire is paying close attention to detail.

Attention to detail is important when going through materials such as documentation or tutorials. Typos and misspellings typically will result in error messages or bugs. Seeing error messages is an experience that is frustrating at first, but is a crucial step in the learning process.  Having error messages and problems in this phase teaches you one of the most important skills of programming in a safe environment: being detail-oriented.

Debugging error messages is incredibly important.  The fact of the matter is that error messages are just a part of programming: they are seen by both very inexperienced and very experienced developers.  The more experience you have dealing with error messages, the less time you’ll need to spend trying to fix them.  Here’s why:

• You will learn how to read error messages and extract the relevant details of the problem quickly.  The first time you see an error message, it will take you a while to decode what it actually means.  After you’ve seen hundreds of error messages (and you will see hundreds!), you will be able to pinpoint the problem’s location and the relevant details you need in order to fix it.
• You should learn from each error message that you resolve.  Don’t just fix the error; understand what was wrong with the code you had before.  By making the mistake and learning from it, the next time you make the same mistake, you’ll be able to fix it much faster.
• Initially you will probably start by asking for help on each error message you see.  Over time you’ll learn how to ask for help less frequently by double checking your code and conducting smart Google searches.

In the tutorial phase, you will follow instruction.  At first you’ll find following instruction quite difficult and error messages will happen frequently.  Over time you’ll develop the skill of debugging errors and have a better attention to small details and you’ll be able to make progress quite quickly.  As you’re wrapping up the tutorial phase you’ll be able to write code at a rapid pace.

At this point some people feel confident, like they’re ready to ditch the training wheels and start building things without structured guidance and will happily dive into the deep end. Other students will reach to more tutorials, trying to obtain more domain specific knowledge to gain a “full understanding”.  Unfortunately, tutorials will only take you so far, and true confidence isn’t found in tutorials, or guides.  It’s found from struggling with a problem you have no idea how to solve and discovering a solution on your own.

The dirty little secret of programming is that…

When you learn to code, you will never know everything you need to solve all your problems.  Going into the journey, you probably thought that you wanted to learn everything you needed and then be squared away.  This moment will never happen.

Programming is a life-long learning experience.  Experienced software engineers seek out to solve problems they haven’t yet because it gives them an opportunity to learn more.  If you’re waiting for the moment you realize you know everything there is to know about coding, you should be aware: the day you’re waiting for will never come.  And this is a wonderful thing.

You will be ready to jump into the next phase of your journey when:

• You’ve seen enough error messages that they no longer startle you. Instead you know how to decipher what it means and where to look for the problems in your code.
• You’re a pro at Googling and finding solutions.  When you’re looking to add a feature, or see an error message you know what to search for and how to find it.
• You’re able to reference code you’ve written in other parts of your application and follow patterns within them, rather than step-by-step instructions.

The Inflection Point (2-4 weeks with the right mentality)

The inflection point stage is one of the most frustrating stages in learning to code, but in many ways it’s the only stage that matters.  It’s the point where you will phase off of using tutorials and start solving problems where someone else hasn’t lined up solutions for you.

At some points you will feel like you aren’t ready to tackle this phase and want to return to building something that was outlined exactly how to do.  Don’t fall prey to this mentality.  The reason you’ll feel frustrated is:

During the inflection phase you will be coding 10-20 times SLOWER than in the previous phase.

You may start questioning yourself and if you actually are capable of becoming a programmer.  Feelings of insecurity and doubt here are common.

Despite the fact that you’ll feel like you’re learning, and accomplishing things at a much slower rate, you are achieving the things that matter the most.  While your domain specific knowledge screeches to a putter, everything you’re learning is about procedural knowledge.

Procedural knowledge is how to teach yourself what you don’t know along the way.  When you need to implement a new feature, what type of a Google search should you do?  At this point in time you’ll feel like you’re “in the dark” when it comes to many of the things you want to accomplish.  Learning how to find the light on your own is critical because you will never know everything about programming, so you need to learn how to teach yourself how to solve the problem at hand.

Most people do not realize that in order to learn to code, you need to learn both aspects: domain specific and procedural knowledge.

The rest of your life…go outside your limits every single day

Some software engineers stay inside their comfort-zone after they gain their footing.  These types of programmers are known as maintenance programmers, and it’s something you shouldn’t strive to be.  You should strive to go outside your limits every single day. The most common reason programmers quit their jobs is because “it’s not challenging any more since I’ve already solved all the interesting problems”.

Rather than seeking to pull coding projects into your comfort-zone, you should be seeking out problems that are outside your current skill-set. This will enable you to expand your skills.

In words of a student of theFirehoseProject who moved passed his inflection point:

I still feel like I’m in the deep end! I’m just getting more comfortable knowing that’s where I’ve got to be!  

In web development there are actually two inflection points that will come together.

The Web Development Inflection Point is the point where you are capable of building any database driven application that you want.  This means you can build a web application with any pages, that stores and retrieves information from a simple database.  Web Developers call this: “Mastering CRUD”.  At this phase you should also be able to integrate with any 3rd party library (a ruby gem for example) simply by following the documentation on GitHub or a blog post.

The Algorithm & Data Structures Inflection Point is a less superficial inflection point, but it is actually more important.  Someone who has conquered this point will have mastered the programming language they’re working in, in addition to mastering programming fundamentals and having a depth of knowledge when solving complex coding challenges.

People who have conquered algorithm and data structures inflection point will be able to:

• Write sorting algorithms
• Implement and Reverse Linked Lists
• Understand and write programs leveraging stacks, queues, trees
• Write computer programs using recursive or iterative solutions

In short, once you pass this inflection point you will have mastered manipulating data and will understand performance implications of code decisions. Traditional computer science degrees focus exclusively on getting students passed the algorithm and data structure inflection point.  Many universities teach this with programming languages that are generally unused in the industry, like Scheme, Racket, or LISP.

Most technical interviews will start with the assumption that you’ve passed the web development inflection point, since it’s easier to do, and focus their questions to see a candidate’s skill in algorithms and data structures. These questions will generally focus on questions like we mentioned above (sorting algorithms, reversing linked lists, using stacks, queues, and trees).

Once someone has passed both the web development inflection point and the algorithm inflection point they hold the keys to the kingdom.

Those people will be able to solve challenges that intersect the two: complex algorithmic challenges that need to be built in the context of web applications.  This is the heart of what all professional web developers do every single day.

Consequences of the Inflection Point

The biggest consequence of the inflection point is a bit counter-intuitive when you first hear it.  Take a deep breath in:

Yup.  I’m not joking; it really doesn’t matter that much at all.  Once you pass the inflection point the concepts that really matter will fluidly translate with just a week or two of tutorials, maybe only days!

What really matters is:

• You have a solid grasp of a web development framework
• You have a solid grasp on writing algorithmically complex code in any programming language

Hiring managers want solid web development and algorithm skills

While I was working at PayPal my team hired a Senior Rails Developer, who had no experience in Rails; he had been coding a lot in python, lisp and perl. Within a couple of days he was already making a big impact.  And within weeks: a huge impact.  He quickly rose to become the technical team lead, and was one of the best hiring decisions I’ve been directly involved in.

Don’t sweat the stack.  Many people will say that “AngularJS is hot these days”, “JavaScript is on the rise”, or “the latest fad is….”.  My response to that is: “so?”.  When you start learning how to program your singular goal should be to find the inflection-point and annihilate it.  Once you do learning that new, sexy fad won’t be a hard task at all.

Become self-reliant.  By being able to learn new skills about coding without structured guidance, you no longer need to wait for anyone to help you out.  This means that for most things you need to learn, you can by searching the Internet and reading many different posts you can learn everything you need to.

This doesn’t mean you immediately “know” everything, but now everything is “figure-out-able,” so you are unstoppable.

The Skills You Will Develop During the Inflection Point

As a software developer, the world’s best reference material is similar code that you have already written. When you fully understand the code you’ve written, you don’t need to commit all the details to memory . This means that the first question you should ask yourself when building a new feature is: “Have I built something similar before?”  If the answer is yes, revisit the code, walk through the code line-by-line in your head.  Re-explain to yourself what it’s doing and ask yourself, “could I use the same approach here?”.

Videos suck for explaining domain specific details, because they take so darned long to watch.  If you want to integrate with the Google Maps API and you already had, once you get experience, it can take less than a minute to open the code up on GitHub, copy the code, and paste it into your new project.  Videos on the other-hand will often take 10-30 minutes to re-watch.

Strategies to Pass the Inflection Point as Efficiently As Possible

Since passing the inflection point is the most important part of learning to code, you should set yourself up to have the process go as smoothly as possible.  This means you should start preparing while you’re going through tutorials and maintain the right mind-set during this period of time.

During the tutorial phase, take breaks from going over the structured material and give yourself challenge problems along the way.

• Every handful of lessons try to do something that is outside the scope of the tutorial you’re going through.  If the tutorials you’re going through provide “Challenges” or “Self-Directed” problems, solve all of them. Solving unguided challenges will give you the important experience of doing things without structured guidance.
• Try to use the tutorials as little as possible.  At the FirehoseProject, we often walk students through how to integrate certain gems, or do things based upon the documentation that we link to on GitHub, or ruby documentation.  Rather than going through the instructions explained in the tutorials, geared towards people starting out, many students will follow the documentation and use the tutorials as a back-up.  The documentation will always treat you like a developer who has passed the inflection point.  By getting comfortable reading and following documentation on GitHub you will have a leg up when you’re on your own.
• Focus on the essentials and use repetition to do the same thing a number of times.  Learn how to do things common things like spinning-up an application from scratch, pushing a new app to GitHub and Heroku, building a database migration early on.

Pushing through the inflection point can be challenging.  Here are some pointers to get you through it:

• Understand this is a difficult process and go easy on yourself.  Also set realistic expectations.  You can’t compare your “superman” level speed going through tutorials to the “snail” speed of learning things on your own.  Keep in mind you’re learning plenty of things, but they are not “domain knowledge”, because at this phase you’re learning how to figure out new things.
• If you’re feeling problems with your self-confidence, know that it is completely normal.  Keep working.  If you’re struggling, talk to someone who has just recently passed the inflection point: they will certainly be able to relate and will assure you went through the same experience not too long ago. Work consistently, but don’t overwork yourself.  At this phase of the game, know that you can be productive for around 6 hours a day maximum.  Working in an exhausted state will only prolong the time you spend passing the inflection point.

The best way to gain confidence in this stage is to power through doubts you have.  Your emotions may start to feel like a roller-coaster.  At first you’ll feel like you’re on fire, but after 15 hours of struggling on the same problem it’s common to feel the opposite.

It can be frustrating to have no idea if something will take you 5 minutes, or 5 hours, but every time you power-through and implement the feature the rush of confidence will be everything you need.  After solving a handful of hard problems without any help, you’ll be addicted to the feeling of building something outside your comfort-zone.

How to know when you’ve passed the inflection point

The final stage of the inflection point process is acceptance.  Acceptance that software development is a process of continual learning.  Acceptance that when you feel like you’ve learned everything that you need to, it means you should start thinking about solving more complicated problems.

Have you experienced the inflection point yet? Share this post and start a conversation with your friends; you will be surprised with how many people have reached this moment.