12 resolutions for programmers（程序员的年度计划）

 

12 resolutions for programmers

英文原文： programmers-resolutions

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.

 

 

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.

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:

• Racket.
• Haskell.
• Scala.
• Erlang.
• Clojure.
• SML/NJ.
• OCaml.
• Squeak.
• Prolog.
• Datalog.

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:

• Logic.
• Discrete mathematics.
• Calculus.
• Probability.
• Statistics.
• Abstract algebra.
• Number theory.
• Category theory.
• Order theory.

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 likePasswordSafe 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.

With cloud-based backup services like Mozy and Carbonite, seamless automatic backup is easy to set up.

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:

• Writing CEK-style interpreters (or semantics) in Haskell.
• Parsing with derivatives.
• Missing method: How to delete from Okasaki's red-black trees.
• Pattern-matching regular expressions in Scheme using derivatives.
• Converting regular expressions into NFAs.

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:

• Chinese.

 

      对程序员来说，挑战自己很重要，没人甘心在创意或技术上停滞不前。犹他大学计算机教授 Matt Might 分享了他的年度计划，引发了很多人的共鸣。

　　1. 感受线下生活

　　当你感觉生活被网络束缚，所得渐渐变少时，请尝试对线下生活（例如烹饪、天文和木工）多投入一些精力，可能有意想不到的收获。

　　2. 保持健康

　　程序员时常久坐，这让我们容易受到一些特有的健康问题困扰，却又往往视而不见。用一个月时间养成一项健身习惯，也别忽视身体的警告。

　　3. 拥抱不适

　　在我二十出头时，曾经研究年长者为何有人不断进步，有人停滞不前？答案是“舒适”。我们习惯找到一个适合自己的系统就不再改变，但技术不是这样。

　　4. 学门新编程语言

　　只会一门编程语言将限制自己解决问题的范围，职业生涯也会少了一些选择。用一个月时间学一门新语言（如 Racket、Haskell、OCaml）或新的编程范式吧。

　　5. 自动化

　　程序员身上最没有充分发挥的潜力是像在虚拟世界那样，让真实世界也实现自动化。试着用一个月的时间研究下机器人、Arduino，以及类似 Insteon 的系统是件有意思的事。

　　6. 学习数学

　　计算机科学的核心是数学法则，更好的数学技有助于成为更优秀的程序员。尝试系统学习一下逻辑、离散数学和统计学。

　　7. 关注安全

　　很少有程序员养成了良好的安全习惯，试着用密码管理器保存和生成密码，研究一年中影响最大的安全事故是怎样发生的。

　　8. 备份数据

　　每年都用一段时间检验你的备份策略，研究如何让这套系统成本更低，使用更便捷。对于关键文件要使用版本管理系统。

　　9. 学习新软件

　　为自己开发的软件增加创意的一个方式是，学习其他新软件。如果你没尝试过 3D 建模，那么可以学 Blender；若你不会 LaTeX，很值得尝试。

　　10. 完成一个个人项目

　　倘若你一直在为别人开发软件，那何不为自己也写一个呢？花一个月的时间完成它，然后把它开源。