Learning to code: DIY and its limitations

So I just completed my first official ‘high-level’ programming course in Python, thus the lack of posts in recent months. I took the course through NYU SCPS, which I viewed previously as an overpriced, rather mediocre continuing education program. I guess my experience with classes in database dev and project management (duh on the latter) were not the best. However, this Python course was awesome, and it proved the value of a real programming course with a real instructor.

I’m a big believer in DIY education, particularly with regards to programming and computer science. It’s one of the reasons I get out of bed in the morning to go into work and help publish professional computing books. I like the fact that with some relatively inexpensive eBooks, trial and error, and now open courseware from places like MIT, you can teach yourself how to code from the ground up. It breaks down barriers–you don’t necessarily need a degree in CS from Carnegie-Mellon to have a career. As an example, I just discovered that the CIO of my company never went to college.

However, there is a major problem with the DIY path: you have to be really self-motivated. It’s just tough to get through an 800 page Python book. What ends up happening, for me at least, is that I grab some basic concepts, get frustrated and/or bored, and then jump directly into practical applications. This is OK, but you end up banging your head against the wall a thousand times, Googling errors and using questionable code snippets. Then serious problems arise when you try to jump into more advanced topics, for example OOP. You just don’t have a broad enough base to code at a high level.

Classes do a couple things to address this problem. First and foremost, in a good course the instructor keeps you motivated and challenged. With a proper cycle of concepts/lectures and practical examples, you end up building skills in a more intelligent way. Also, when you are ready to launch into more advanced topics, the scaffolding of skills you’ve gained is there to support. Building blocks, as cliche as it sounds.

Right now I’m running an interesting project for work, trying to create interactive content to teach people web dev languages. On a surface level, it’s a project common to many publishing companies (or any company in the ‘content’ business) right now. How do we leverage new technology and web standards to make content more interactive? However, when you look specifically at teaching people how to code, things get interesting on a conceptual level.

Many of the problems with the DIY method may be addressed by leveraging new technologies and re-structuring content–for example, incorporating screen casts, interactive tutorials, and perhaps even connecting to real-world projects somehow (Github?). All of these things could help bring the benefits of a real course to an otherwise flat book paradigm. Indeed, there are some companies out there pushing the boundaries already, like Code Academy and Markana, but no one I feel has really brought it all together.

New publishing technologies aside, I think what ultimately works best is a blend of courses and DIY. Right now I’m about to jump into some Django books, which I’m fairly confident about given my Python skills from the course. Had I half-assed a reading of an intro Python book and then jumped into Django, I probably wouldn’t get too far. Then again I might do just that for Rails. And whether it’s better right now to jump into Rails as opposed to Django is a topic for another post.

  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: