Despite being a graduate of a "coding bootcamp", I still consider myself to be self-taught. While my 3-months of coursework helped me polish my skills, I went in with siginificant development experience already under my belt. I've been hacking at desktop and web programming since I was 8, and I've seen a TON of training services come and go. One of my biggest challenges as someone who has frequently jumped into and out of the 'programming pool' is finding training that works for me. In talking to other self-taught devs I've heard the same issues come up again and again, so I'd like to address the issue and offer some suggestions for getting over the hurdle from knowing a little bit to knowing a little bit more.

The Problem

One of the biggest challenges to being self-taught is finding intermediate resources that remain engaging once you know a little bit. The issue is that most training assumes zero knowledge. Certainly, this makes training more accessible: anyone can drop into any course and get up to speed quickly. However, assuming zero knowledge means interested students with a little experience have to sit through the same "Intro To HTML", "Array Basics", "What is MVC?" and "Database Fundementals" content over. And over. AND OVER. This is a great way to reinforce skills early on, but it doesn't take long for this repetition to become the difference between being engaged in a training solution and "changing the channel". Zed Shaw, a well-known developer and online teacher, recently shared a blog post that sums the issue quite nicely: "Early vs. Beginning Coders". This issue translates in steps up the knowledge stack - transitioning from a true Beginner to an "Early" coder is analogous to transitioning from an "Early" coder to a "Junior", or a "Mid-Level", or whatever tiered structure you maintain mentally to separate those with more experience/skill from those with less.

How Did We Get Here?

Historically, programmers were a fairly insular group. As languages and needs havd spread farther and wider, so has the development community. This has resulted in sharding of knowledge and access to resources. The learning curve for someone in San Francisco, with access to frequent meetups, gatherings, free training and classes, is theoretically much smoother than for someone in rural South Dakota with no connections and limited training opportunities. This is especially true for people who learn best in-person. There's been a huge proliferation of bootcamps and physical locations offering programming coursework in the best 5 years, but service still isn't consistent. Location is still a huge factor in considering what's available to a learner.

What's Been Tried

It'sno secret that there are people out there who want to learn and who don't need the basics all over every time. I see training solutions attempt to address this gap frequently. Some tactics I've seen that I'd consider "antipatterns":

  • "We'll assume you've completed our Python I course.": This is well intentioned and a good start but I always see it fail in specific ways. Often, a course will offer this disclaimer and then start right where the first course left off, leaving the learner wondering what the insturctor means when they say "As you'll remember from Python I". This frustrates me. Maybe I already took some basics from a MOOC or a competing training program. I shouldn't hvae to review your material to take advantage of advanced training.

  • "You can skip ahead if this seems familiar.": Again, kudos for trying. But where should I skip to? If I skip too far and feel lost I supposed I can skip back, but how long should I twiddle the playback slider before I decide this course isn't right for me and move on? Why am I having to ask so many questions before I even start learning? Back to the URL bar I go.

  • "This course assumes a thorough knowledge of Ember.": Courses that start with this kind of vague disclaimer always go one of two ways:

    • "Come on, I don't need to review the entire framework."
      OR
    • "Oh, so we're linking up to C libraries? Metaprogramming? Well, shit."

    We need to agree on a more explicit distinction than "thorough knowledge" or "familiarity with". These terms don't mean much in a world where each and every person has been exposed in different ways and different environments.

  • "Allow me to introduce myself.": This one may just be a personal pet peeve. I appreciate the time instructors put into courses, but I don't need you to read your CV or impress me with your credentials. That's what "Bio" sections are for on websites. I'm here to learn. Let's learn.

Techniques and Tools I Find Helpful

Here are some things I've found helpful in learning at a more intermediate level, and some sites/tools that employ them:

  • Short Videos: 5 minutes. 10 minutes at most, for very complex topics. I always really appreciate when a course is broken up into bite-size pieces so I don't have to commit to an hour of watching or slider-twiddling to discover if it's a good video for me. One master of this tactic is Railscasts.

  • Tight Scoping: At an intermediate level, I want a "Getting Started With..." course to cover only its subject matter, not fringe information or ramp-up needs. Density is a good thing - I'd much rather step through a short course with lots of info a couple times than have to fast-forward through a long course. Classes that focus on one subject, in depth, and ignore side notes and edge cases work best for me. I've found some real gems in the intermediate/advanced levels on Treehouse (referral link).

  • Interactivity: I like to stay engaged. Even really good videos get boring after some time. A lot of courses have started providing interactive demos, quizzes and code challenges as part of their training. Even better is when a course provides a go-to "sandbox" environment, where I can duck out of a video with a question and answer it myself through trial and error. The best use of this technique I've seen has been at A Tour Of Go.

  • Real Applications: We've done Fizzbuzz. We've walked through a fibonacci printout. We might have even worked out Conway's Game of Life. The best training moves past these kinds of thought exercises (which are totally excellent but get repetative) and into actual real-world concepts. I love stepping through an app's development from start to finish. I enjoy getting insight on scaling and resource concerns. These kinds of things become more important as you move higher up the "programmer food chain", and they open my mind to see more than just the code I'm working on. I've gotten the most on this front from Code School's "Soup to Bits" videos.

  • Community: Ultimately, the best teacher is teaching. Being able to explain topics to others locks them in your mind and forces you to understand them at a deeper level. This is why a good community surrounding whatever tool(s) you use is so important - it lets you interact with other people near your level of understand so you can share knowledge and grow yourself. Even better, a good community can act as a motivator to keep you diving deeper. Hands down, the best community I've seen online has been at Free Code Camp. There's not a bully in the bunch over there.

Looking Forward

We're quickly reaching a point where the "beginning coder" is less common. Kids are getting programming exposure at earlier and earlier ages and the concept of programming as literacy shows no signs of slowing down. This means the need for intermediate training will continue to grow as we move ahead. I'm hopeful that some of the existing schools out there will step their games up and utilize the immense resources available to them to offer their students the next steps, but if they don't it won't be tough for new programs to clobber them. Intermediate-level training is definitely the next big step in the web education front.