Deliberate Practice for Programmers

The main reason one should go to graduate school is to do research. To earn a PhD you must have advanced the state of your field. In fact, your PhD defense is all about convincing the guardians of the frontier that the frontier has been moved. That being said, I have a personal goal of improving myself as well. I’m surrounded my brilliant professors and peers and it would be downright stupid if I didn’t take this chance to learn from experts in their fields.

While I want to improve as a computer science researcher I also want to improve as a developer. For me, the fact that we must take our beautiful algorithms, logics and abstractions and express them in terms understandable to a dumb machine is not something to be despised. In fact, I consider it a pleasant challenge and a source of infinite creative joy. I would like my job a lot less if it didn’t involve a significant amount of programming. That being said, how exactly do we level up as a developer? In fact, what does leveling up even mean for a developer?

For the last few months (years?) I’ve been a growing fan of the idea of deliberate practice – the idea that the best way to improve is to take well-defined measurable steps towards getting better where at each step you get feedback as to what you did wrong and how you can do it better the next time. Deliberate practice has been applied by athletes and writers, can we apply it to programmers? In particular, can we come up with something more detailed than “Read code. Write code. Repeat”? Luckily for all of us, Jason Rudolph took some steps on that path a few months ago.

Remember that deliberate practice requires that we have a list of well-defined, actionable goals on our path to excellence. We must know clearly what the goals are and also be able to unambiguously tell if we’ve achieved them or not. Jason came up with a list of simple yes/no goals that will exercise your programming muscles. What I love about Jason’s list is that it combines a lot of what it means to be a good developer. There are goals for learning tools of the trade (different languages, environments and frameworks), goals for learning core concepts (different paradigms and parts of the software stack) and social goals (open source and community involvement). There are a lot of things on the list, but then again, computer technology is a vast field.

Jason’s list is also necessarily incomplete. I’d argue that it’s practically impossible for one man to know all about the computer technology field today. But the good thing is that we have the technology and the community to take one man’s starting point and extend it for our own purposes. Jason’s list is available as a gist on Github and has already been forked many times by people who are using it as their own deliberate practice guidelines. I have my own fork where I’ve fleshed out sections on uncommon programming languages and more theoretical learning goals.

It might be a bit naive to think that just going through a list of programming challenges will make you level up. However, I think the list is a good head fake. The point isn’t really to go and do everything on the list. The point is everything that comes as a side-effect of completing the list. You’ll definitely put in a few thousand hours and churn out thousands of lines of code in a variety of different languages and environments. You’ll expand your mind by learning about programming styles and tools that you would have missed out on otherwise. As you encounter problems you’ll have to ask around on forums, mailing lists and IRC for help. This is important because deliberate practice is useless if you’re practicing the wrong things. In the absence of programming coaches, the global communities of programmers are your best bet to find mentors and guides. If you release your code to the world you’ll gain some street cred, get valuable feedback and maybe even provide something of lasting value to fellow developers. If you follow through on the social and community goals you’ll gain non-programming, but useful skills and meet a lot more people who can point in new and interesting directions. You’ll discover interesting new problems and come up with applications and solutions you might never have thought about otherwise. Maybe, just maybe, you’ll learn enough to level up as a programmer.

As a parting note, let’s all keep in mind that this will not be easy. It will take time and effort. I’m in graduate school so I might be able to make it part of my day job to do some of these things. But a lot of it will have to happen on my own time and energy, when I could be exploring Ithaca’s gorges or watching infinite Star Trek episodes on Netflix. This is even more true for people who have legitimate day jobs and families. We all need to come up with our own reasons for why we want to invest all this time and effort in deliberate practice. But one thing I keep telling myself is that the time will pass anyway and my energy will be spent somehow. I would rather spend it on writing my own operating system than on Star Trek reruns (no matter how much I love Star Trek).

Is programming a creative pursuit?

It’s becoming clear that we, as a society, are placing a larger and larger emphasis on innovation and creativity while at the same time bemoaning the lack thereof. There are some activities that we instantly recognize as creative pursuits: painting, music, writing, theatre. And also more modern ones: graphics, web design, info graphics and industrial design, font design and lettering. But when it comes to modern acitivities and professions one of the elephants in the room is programming. The question that’s been on my mind: is programming a creative pursuit?

Programming is problem-solving. It’s about coming up with ways to do things that couldn’t be done before (or at least doing them better). But that’s just the beginning. Once you figure out a way to solve the problem you then create something – a program – that embodies your solution. The program is what goes ahead and solves the problem, hopefully correctly and repeatedly. A program that only works once isn’t very useful. If you’re not creating anything, then you’re not a programmer.

That being said, I think there are some significant differences with typical creative work that needs to be made clear. For one thing, there’s lot less waiting around for inspiration to hit. There isn’t anything really analogous to writer’s block – once you have a problem to chew on you can get going. That’s not to say that you can’t get stuck or that it’s smooth sailing. Far from it, your typical programmer is pretty experienced in applying head to desk. When you don’t have a definite problem to solve it’s a different matter. Luckily there’s lots of interesting software that needs building and problems that need solving. To get out of the rut you just need to do a little Googling (or keep a little stash of side projects to hack on).

Perhaps one criticism of programming as a creative endeavor is that the products aren’t instantly identifiable as creative works. Perhaps if you spent a lot of time crafting GUIs you can make some comparison to the visual arts. If you’re writing server software or building programming languages the end results are far more abstract and invisible. But I’d make the argument that a programmer produces a work of art in the same way that a novelist or a poet does. Understanding that art requires the use of some more mental faculties — understanding symbols, structures, mathematics, semantics and their inter-relation. The process is perhaps harder than looking at a painting. But the payoff to the observer is no less than listening to, and appreciating a piece of music.

All that being said, one of the coolest things about programming is that you can use your programs to produce obvious art work, or write programs that will create art for you. As I’ve been exploring programming and computer science I’ve been thinking of programming as a medium for expression in the same way that music or art is a medium for expression. But more on that later.

Programming has some of the other hallmarks of other creative pursuits. You need lots of practice to get any good. When it’s time to actually create you need to isolate and separate yourself from the rest of the world or you just keep getting distracted. I think there’s an image of programming being dry and interesting only if you’re already into it while the classic creative arts are supposedly fun and energizing. I would argue that’s an unfortunate by-product of our social evolution. If you consider a creative person (or want to become one) I would say give programming a try. There are lots of ways to get started. Though the learning curve is certainly steep (and probably steeper than it needs to be) it’s probably not that much harder than learning to draw or play the violin.

UPDATE: Thanks to Jason Yosinski for pointing me to Hackers and Painters – a far more detailed essay on similar considerations by a far wiser person. Learn from the masters.

deck.js lite: modern HTML presentations

Taking a page out of Don Stewart’s book I’m planning to release a project to the Internet every week or two. Most, if not all, of them will be open source and hosted on Github. I’ll be posting blurbs about them on this blog filed under a new category – Projects. Feel free to follow along or fork away.

Deck.js is a very cool project that provides a set of CSS and JavaScript templates that let you create clean, elegant slideshows using HTML. I’m becoming increasingly attracted to HTML as a general purpose documentation format so seeing like deck.js makes me really happy.

I’m currently using deck.js to put together a presentation for a class I’m taking, but while at it I thought I’d do some reorganization of the deck.js codebase to make things a little easier. The files that you need to include to use deck.js are currently spread out between a number of different folders meaning that as a user it might take you a while to figure out where everything is and what you need to include. So in the spirit of open source I decided to fork the repo on Github and create a ‘lite’ version.

This version (also available on Github under the same license) packs all the files into a single folder, shortens some names and paths and removes some things (tests and SCSS files) that users might not care about. I’ve also updated the introductory presentation to point to the new files so you can use that as a template for making your own slides. I’ve been talking to deck.js’ creator, Caleb Troughton and I plan to keep the ‘lite’ version in sync with the main repo so that you’re always using the latest and greatest.

If there’s anything else you’d like to see in a lite version (or just in deck.js in general) please let me know. I think the best days of the web are just ahead and having web-native slideshows is definitely a step in the right direction.

PS. In case you’re wondering: no, The ByteBaker is not going to become just an announcement board for my projects. However, graduate school is taking up a lot of my time and energy right now. Also I think it’s important that I keep to releasing one project a week. The best I way I can think of keeping to that is by documenting my progress online. Normal programming will resume soon.

Bluebot: a simple HTML template

Taking a page out of Don Stewart’s book I’m planning to release a project to the Internet every week or two. Most, if not all, of them will be open source and hosted on Github. I’ll be posting blurbs about them on this blog filed under a new category – Projects. Feel free to follow along or fork away.

Over the weekend I took a few hours to set up a simple webpage on the Cornell CS department servers. While doing that I realized that I didn’t have a template in store for the occasions where I needed to throw together a page without fiddling for hours. I cobbled together a simple design for my page based on my personal website.

The result is Bluebot: a simple template designed for creating HTML5 webpages. It provides a set of CSS styles and web fonts along with some example HTML for writing clean, decent-looking webpages. It’s designed to be used for standalone pages, i.e. single webpages that are complete in and of themselves. That’s not to say it couldn’t be used or adapted for full websites.

Though the template is mostly black and white, there is a little bit of blue used for the borders and blockquotes, hence the blue. It also makes use of the Droid family of fonts provided via Google Web Fonts, hence the bot.

You can see what Bluebot looks like on the Bluebot project page. You can clone the Git repo or download a tarball from the Github page. I plan on continuing to add styling for the remaining HTML5 elements gradually. Feel free to fork, edit and send me a pull request.