For an industry that prides itself on its analytical ability and abstract mental processing, we often don't do a great job applying that mental skill to the most important element of the programmer's tool chest - that is, ourselves.

Undoubtedly, if you've been working in this industry for a couple of years, you've met people who, despite whatever first impression you might have had of them, turned out to be somewhat disappointing in how they go about their lives. Even as I write this, I think about a business analyst employed by a consulting client of mine: she's the absolute soul of negativity about everything. Users are stupid. The software is a mess. Any feature we discuss is probably going to take too long and cost too much. Any feature we don't do is one that every user absolutely has to have and will cause them to abandon the company if we don't do it - and yet if we do plan to do it, we'll probably screw it up anyway. Even when she went on vacation to Cabo San Lucas, she came back and said, “Yeah, it was too sunny, too hot, and had too many drunk people.”

It's not just about negativity. People can find ways to sabotage themselves. Or they talk themselves out of taking even the smallest risk, even if it would yield a huge positive gain. And so on. And then they wonder why “success,” for whatever definition of the term you care to use, eludes them.

Last year, Amy Morin posted an interesting list on LifeHack entitled “13 Things Mentally Strong People Don't Do” (at, and the list gathered enough attention that it spawned a number of reactions and re-posts, including on A reader pointed it out to me, along with the comment, “I'd love to see your take on this with respect to the programming industry.” It's a good list, so without further ado, allow me to present my own take on this.

The 13 Things Mentally Strong Programmers Avoid

Here's a short list that I hope you'll find useful.

1. They Don't Waste Time Feeling Sorry for Themselves.

The mentally strong programmer owns their code and their context in life. If the code doesn't do what you expected, it's not because the compiler has a bug, or the library has a bug, or your co-worker screwed up the database. It's because you made a mistake. Own up to it. Take it as an opportunity to learn something new and improve yourself.

2. They Don't Give Away their Power

There is an old saying that goes: “Hating somebody for what they did to you is like swallowing poison and expecting it to hurt somebody else.” Saying something like “My boss makes me feel bad” is a statement of surrender: nobody can make you feel anything; they can only try to influence your thinking. More importantly, more often than not, your boss isn't trying to make you feel bad purely for the sadistic enjoyment of it - there's usually a reason behind their actions, too. Find out what that is, and you find a way to make the negativity go away entirely.

3. They Don't Shy Away from Change

Let's face it: If you don't like change, you are in the wrong industry. The only thing constant in software is change. That said, change for its own sake is often not a good thing, either. The mentally strong programmer looks at the changes proposed, and asks the hard question: “What does this change net us?” More importantly, when presented with an opportunity to learn something new, they embrace it, but always with an eye towards positive improvement.

4. They Don't Waste Energy on Things They Can't Control

This is true both of life (lost luggage or traffic jams), but also business (changes in business direction that necessitate a complete change of priorities in the project, or the departure of a favorite co-worker or manager) and technology. Sometimes the only thing we can control is our attitude. That doesn't mean always being happy, because let's face it, being fired sucks. But being fired also means an opportunity to find a new gig, and sometimes the new gig turns out to be far better than the old one.

5. They Don't Worry About Pleasing Everyone

It's a simple impossibility to please everyone; for any action “X” that you might undertake, some people will approve and others will disapprove. Just as others can't make you feel one thing or another, you can't make anybody else feel anything. What you can do is be professionally honest to yourself and your co-workers, but do so without malice. Speak up when the boss wants to do something stupid, but don't lord it over them, or you'll be on the receiving end of that same feeling when you want to do something stupid.

6. They Don't Fear Taking Calculated Risks

In the corporate environment, this is actually very, very hard to do. Taking a chance and failing is about the only thing that will get you fired faster than mooning the CEO's cousin at the company Christmas party. That said, though, being the one to suggest a well-thought-out and informed risk and carrying it through can yield huge career benefits. And honestly, there's a lot more to be learned from failure than from success - which is why we call them “prototypes.”

7. They Don't Dwell on the Past

Yes, it would be nice if we could all go back in time and make different decisions. “If only we'd not used VB6 for that project, we wouldn't be in this mess today.” When playing the “what-if” game, remember to play it fairly: yes, things might be better today, but they could also be a lot worse. (You might have chosen to use PowerBuilder, and God knows, nobody wants any part of that today.) People made the best decision they could with the information they had at the time, and there's nothing we can do to change that, so acknowledge it, learn from it, and figure out what we do from here.

8. They Don't Repeat the Same Mistakes

Acknowledge the past, learn from it, and move on. All three parts of that statement are critical, because if we don't learn from it, it's really likely that the same mistake will happen again. “Good decisions come from wisdom. Wisdom comes from bad decisions.” Take the risk, maybe fail, learn the lesson, get better. Lather, rinse, repeat.

9. They Don't Resent Other People's Success

Watching a co-worker get the promotion or the job you really, really wanted is a hard thing. It's easy to nurse jealousy and/or resentment, and doing so only hurts you. Acknowledge that you're disappointed, but again, learn from it. What enabled them to succeed? Did they have knowledge you lacked? Did they have a relationship with upper management that you lacked? Were they more in tune with the business needs? They got that job or promotion instead of you for some reason, and your chances of success go up substantially if you can figure out what it is. Sometimes the reason is simple: they took the risk, and you didn't.

10. They Don't Give Up after the First Failure

I've watched programmers throw their hands up the first time they didn't “get it,” whether it was learning a new technology or trying to get the code to work, and start rattling off all the reasons why this will never work. After sitting with them for a few minutes and reasoning through the failure, though, we find the cause, and lo, everything is good again. Yes, it's frustrating when things don't work, but don't give up. Talk through it with a co-worker. Or even a teddy bear. (Seriously.) Talking through the problem forces the problem through the speech centers of the brain, and by forcing you to explain the full context, suddenly triggers other thoughts about what might be at fault.

11. They Don't Fear Alone Time

Actually, with programmers, it's often the opposite problem: Programmers love alone time but hate meetings of any form. Don't fear the meeting. Yes, they can be boring, but they can also be an opportunity to discover what other people are working on, or what other parts of the company are doing, and offer opportunities to mentor, help, or just learn more about the business.

12. They Don't Feel the World Owes Them Anything

Yes, you're a smart person. Yes, you can program a computer. So what? When the Zombie Apocalypse comes, you can't code your way to safety, so you're going to be the first one to go. No matter how incredible a programmer you are, nobody is going to hand you a CTO job. You have to earn it. You have to have the technical skills, yes, but you also have to have the ability to manage people, and to communicate with people who aren't programmers.

13. They Don't Expect Immediate Results

It's a staple of our industry: the whiz-kid college dropout who spends two weeks learning a programming language and builds an app/game/whatever, launches it, makes a million-bazillion bucks, and retires at the age of 23 to become a venture capitalist and teach other people how to be successful. It's also more often than not a complete fiction. Results like that don't happen overnight. (Yes, exceptions happen. So do lottery winners.)

Mental Strength Yields Success

These principles often reinforce and overlap. Based on an article you read in this magazine, do you want to convince your company to use NodeJS, or to adopt a more agile approach, or to move to Git? It's a risk - is it a worthwhile one, for your team/company/project? Let's assume it is. It's still not going to happen with just one conversation with your boss. You'll have to demonstrate the value of the change, analyze the costs, and prototype the results. Then, once that's done, you'll have to communicate the benefits, costs, and process of the change to management and co-workers, and sometimes even babysit the change to see it through. Problems will arise that you didn't anticipate, and you'll have to admit the mistake, adapt, and carry forward. Probably more than once.

But once the change is made, you were the one that did it. And that, my friends, is a bone-deep satisfaction that lasts pretty much your entire career.