8 Things That Make Someone Look Like a Master Programmer

I’ve been programming for a few years now and I’ve seen a lot of people come and go. Some were good, some were bad, and some were just awesome.

When I say “awesome” I’m not talking about their technical skills or how good they are at programming. I’m talking about the characteristics that make them look like a Master Programmer.

So what is it that makes someone look like a Master Programmer? Well, there’s 8 things:

I recently had some friends ask me how they could improve their coding skills, and they were surprised when I responded immediately with “You have to write more code.”

I thought it would be useful to elaborate.

Here are eight things you can do to make yourself look like a master programmer:

(1) Read other people’s code

If you read through the code of a master programmer, you will start noticing patterns. You will see how they name variables, format their code, comment their code, and tackle problems. To really understand the code, I suggest typing it out by hand as opposed to just copying and pasting it into your text editor. This will help you understand each line of code a little bit better. After reading enough code, you will start to see similar patterns in your own work.

(2) Refactor your old code

Every few months or so I go through my old code to see how I was tackling problems before. Often times when I read my old work I notice that my current solution is quite different from what I did before. If you refactor your old work too often though (more than once every few months), then this might not be very helpful for you. Some people find that looking back at their old projects helps

Programmers are strange beasts. We have these weird habits that most people don’t understand. We tend to think about problems in a different way. And we often do things that people think are completely unnecessary.

And I like that. It’s part of what makes us different. It’s part of what makes us great.

But sometimes we take our weirdnesses too far. Sometimes they get in the way of our jobs and our projects and the people who work with us.

We end up doing more harm than good, even though we have good intentions. Myself included!

So here are eight “bad” things programmers do that make them look like masters at this craft, but that may actually be hurting them (and their colleagues). And let me tell you, I’ve been guilty of all eight of these at some point in my career.

1. They don’t use a mouse.

2. They program in an obscure language.

3. They don’t use an IDE (or they write their own).

4. They can type fast without looking at the keyboard, sometimes without even thinking about it.

5. Their code is indented very consistently and properly formatted.

6. Their command prompt is customized in interesting ways (colored, non-standard character set) or shows lots of useful information on startup (current git branch, python virtualenv name, etc).

7. Everything they run from the command line has a short alias, typically 2 or 3 characters long.

8. Many of their aliases are clever things that do more than one thing, such as a shell script that’s also a command line menu system for all the other shell scripts they have written in the past week

Programming is a very personal process. What works for one person may not work for another. There is no right or wrong way to program. There are however, a few things that can be learned from watching programmers who are good at their craft.

Master programmers have the following characteristics:

They are good at estimating time. They do not make up random numbers to give an estimate. They do not use the same formula for every estimate and expect it to work with every project. A master programmer understands the factors that impact their ability to get a task done, and can estimate tasks accordingly. This means they also understand what factors will impact their ability to estimate tasks (e.g., familiarity with technologies, familiarity with domain).

They never write code that does not have a purpose (at least in production code). They may write throwaway code during development but it gets deleted before going live. They never write code without tests around it; tests which cover the widest possible variety of edge cases and potential failures. If they do not understand why they are writing a piece of code, they ask questions and do not proceed until they know why they need to write it and how it will be used.

They take pride in their work and pay attention to detail, but they also

It’s a good question. I’ve always been interested in how people can be more productive, but I’ve never had anything to say about programming. After working closely with a handful of the best programmers I’ve ever met, however, I realized that there are some things that come easier to them than to others.

In this post, I’ll share what I’ve learned. The first half is meant as a guide for people who want to get better at coding. The second half is mostly for fun, and it’s my attempt to explain why some people seem like they’re superhuman at programming.

This post is inspired by Paul Graham’s classic essay, How To Be A Good Hacker. He writes: “What hackers and painters have in common is that they’re both makers. Along with composers, architects, and writers, what hackers and painters are trying to do is make good things….”

In the words of Derek Sivers: “If you’re not embarrassed by what you originally made, you shipped too late.”

There are many great ways to learn how to code. If you want my advice on which one I think would work best for you, send me an email.

It takes time and practice before writing code becomes effortless (that

I’ve taught hundreds of people to code, and I’m always interested in how people approach programming. It’s not that there is a single perfect way to code, but I notice certain patterns emerging among the people who seem to learn quickly and just “get it”.

In this post I want to tell you what those patterns are — not because they are the only way to program, but because if you have similar habits then it’s likely you too will pick up coding quickly. And this is what you would want, right?

1. They use a debugger

Professionals use a debugger. This allows them to step through their code line-by-line and see what each part does before moving onto the next bit of code.

Some programmers seem almost reluctant to use debuggers, and I think this is because they feel like using the debugger somehow makes them look bad or means they don’t understand their own code. But this isn’t true!

The fact is that even if you have complete confidence in your ability to write bug-free code on your first try then that confidence is misplaced. You’re going to make mistakes, so you might as well make it quick and easy for yourself by

Leave a Reply

Your email address will not be published.