12 resolutions for programmers

[article index] [] [@mattmight] [+mattmight] [rss]

It's important for programmers to challenge themselves.

Creative and technical stagnation is the only alternative.

In the spirit of the new year, I've compiled twelve month-sized resolutions.

Each month is an annually renewable technical or personal challenge:

  1. Go analog.
  2. Stay healthy.
  3. Embrace the uncomfortable.
  4. Learn a new programming language.
  5. Automate.
  6. Learn more mathematics.
  7. Focus on security.
  8. Back up your data.
  9. Learn more theory.
  10. Engage the arts and humanities.
  11. Learn new software.
  12. Complete a personal project.

Read on for my suggestions.


Update 1: Also see what every computer science major should know.

Update 2: Translations available.

Update 3: 12 resolutions for grad students

Go analog

Programmers obsess over the discrete and the digital well past the point of diminishing returns.

Thus, small investments in the analog yield comparatively large gains.

Here's a starter list of analog activities to try, each of which takes about a month of dedicated effort to transition out of the novice (and into the seasoned beginner) stage:

  • Cooking.
  • Hiking.
  • Skiing.
  • Astronomy.
  • Jogging.
  • Carpentry.
  • Martial arts.
  • Dance.

Stay healthy

Programmers tend to live sedentary lives, and we face unique health challenges from our occupation.

We tend to ignore these challenges.

Spend a full month each year tuning your exercise, diet and environment to promote durable healthy habits.

Go to a clinic each year to get your blood pressure, cholesterol and blood sugar checked. Watch how these values change over time.

If your wrists are starting to hurt or have been hurting, stop now and take action to combat RSI.

Focus on improving your posture, with an emphasis on your shoulders and neck. I use a posture corrective brace to help:


(Yes, it works for men too.)

Track your weight, caloric intake and caloric burn. If necessary, reshape your lifestyle to promote healthier eating and weight loss.

If you're already trim, consider a one-year experiment in packing on strength and muscle.

Embrace the uncomfortable

Since my early twenties, I've looked at my older peers and tried to figure out why some stagnate and how others stay vibrant.

The answer is comfort.

Comfort breeds technical fossilization.

We find a system that works for us, and we stick with it.

But, technology advances, and those that stay in their comfort zone never realize the gains from these advances.

Practice becoming comfortable with being uncomfortable.

Here's a list of things that might make you uncomfortable at first:

  • Switch to Dvorak.
  • Switch from emacs to vim or vice versa.
  • Stop using a mouse.
  • Use a different window manager.
  • Switch from cream and sugar to black coffee or straight tea.
  • Try out that "popular new piece of crap" for the full month.
  • Turn your cellphone off for one day a week.
  • Learn a one-handed input device.
  • Try a different OS.
  • Abstain from the internet for one day a week.
  • Try a dietary restriction: go vegan, vegetarian, dairy-free, etc.
  • Eat a food you don't like every day.
  • Put your dominant arm in a sling.
  • Learn to write with your non-dominant hand.
  • Start a blog.
  • Sign up for public speaking.
  • Listen to a kind of music you don't like for a month.
  • Volunteer at a hospital or retirement home.
  • Fast once a week.
  • Travel to a country with a different language and/or culture.
  • Read an acclaimed novel from a genre that you don't like.
  • Watch an acclaimed movie/show from a genre that you don't like.
  • Learn to drive stick.
  • Argue against something you believe.

After a month of doing something different, decide whether you want to keep doing things differently or whether there are ways to blend the best of the new and the old.

For instance, when I switched to vim after ten years of emacs, I set up the emacs-style key-bindings for insertion mode but kept vim.

Learn a new programming language

Programming languages rise and fall.

Programmers that only know one language will restrict their problem-solving abilities and their career prospects.

Spend a full month absorbing a new language or a new language paradigm.

Write a modest program in it.

Here are a few less mainstream languages to learn:

If you're out of programming languages to learn, implement one.

Automate

The most powerful underexploited skill programmers possess is the ability to automate both the virtual and the physical.

If you've never built a robot, build a robot.

At the very least, play with Lego Mindstorms:

or hack on an Arduino board:

Survey the routine tasks you perform, and determine which can be automated in full or in part.

Home automation technology has advanced considerably, and much is possible with DIY systems like Insteon.

Take a month to invest in an automation project:

  • Tune your mail filters or set up procmail.
  • Set up shell scripts to automate the frequent.
  • Create shell scripts to help your writing.
  • Learn how to use the cron tool.
  • Link closet lights to motion detectors.
  • Replace wires with wireless where possible.
  • Stop manual syncing: Move it to the cloud.
  • Set up a remotely controllable sound system.
  • Control your thermostat from your server.
  • Set up digital security cameras.
  • Create a digital intercom/baby monitor.
  • Have your coffee maker turn on automatically.
  • Set up a self-refilling water dish for pets.
  • Build a sensor-controlled pet door.
  • Hack a Roomba into a personal courier.

Learn more mathematics

At its heart, computer science is a mathematical discipline.

Good mathematicians make good programmers.

Do not let your mathematical faculty wither.

Consider an annual one-month brush-up on one of these topics:

Focus on security

Few programmers practice good security habits.

If you're conscious of your own digital security, you'll be more conscious of the security of the code you write.

Check that you're using unique, strong passwords for every site.

Manage your passwords with an encrypted password manager like PasswordSafe or KeePassX.

If you don't already practice whole-disk encryption, set aside time to do it. (On a Mac, it's painless to set this up.)

Each year, study the top ten vulnerabilities for the past 12 months. How did they happen? What coding practices could prevent them in your code?

Here are other security tasks you can try out:

  • Set up an SSL certificate in Apache.
  • Implement a cryptosystem like RSA or AES.
  • Try to crack the key to your wireless network.
  • Snoop your network traffic with WireShark.
  • Set up passwordless, key-based ssh login.
  • Run nmap on yourself. Configure your firewall.
  • Set up port-knocking.
  • Create an encrypted USB drive.
  • Set up log file monitors.
  • Set a cronjob to upgrade your packages regularly.

Back up your data

Each year, spend time reviewing your backup strategy.

Invest a month in minimizing the cost of making backups.

[I've recently moved to keeping many of my working files in Copy, a slick DropBox-like app that comes with much more free storage than DropBox. Sign up through this referral link to get an extra 5 GB.]

Opt for defense in depth by assigning an individual hard drive to each computer and enabling automatic backups with tools like Time Machine.

Keep critical files in version control with a geographically remote repository.

Learn more theory

Computer science has rich theoretical structure.

Keep abreast of new developments and renew your mastery of the classics.

Spend a month each year on topics like the following:

  • Formal languages.
  • Automata and computability theory.
  • Complexity theory.
  • Formal methods.
  • Semantics.
  • Algorithms and data structures.

For starters, you might want to take a look at these posts:

Engage the arts and humanities

Engineers tend to look down on the arts.

What engineers fail to realize is that the arts and humanities augment technical excellence.

Steve Jobs was fond of pointing out the importance of connecting technology and the humanities, and rightly so.

Art and design have principles applicable to human-computer interaction.

Don't be ignorant of these principles.

Practicing the arts and humanities trains and sharpens intuition in a way that is difficult to quantify.

Engineers need to learn how to measure what they can't count, instead of counting only what they can measure.

For at least one month per year, learn more about topics like the following:

  • Industrial design.
  • Philosophy.
  • Photography.
  • Painting.
  • Sketching.
  • Music and music theory.
  • Film.
  • Literature.

Social sciences have much to offer computer scientists as well. Try economics and psychology in particular.

Learn new software

A good way to get ideas for your own software is to learn a new application or a new kind of application.

For instance, if you've never used 3D modeling software, try Blender.

Or, if you've never learned LaTeX, give it an honest effort.

As you learn, note what you like and don't like.

Ask yourself honestly whether these observations are reflected in the software that you create.

It's hard to spot bad practice in your own work, but easy to spot in others'.

No parent ever had an ugly child.

Learn to recognize your ugly children.

Complete a personal project

If you spend all day writing code for someone else, remember why you became a programmer by writing a program for yourself.

Spend a month each year on a project of your choosing.

Bring the nucleus of that project to fruition.

Open source it and release it to the world.

Translations

This page is also available in:

Related pages


[article index] [] [@mattmight] [+mattmight] [rss]