I'm in senior year in high school. I enjoy programming (Java) very much and aspire to do it as a career in the future. However this isn't the topic of this question.

My question is: how can I start making consistent progress towards the goal of becoming a great programmer?

What I mean is this:

I work on my own projects, enjoy doing so and feel like I'm slightly improving with every project I finish.

However, I don't feel like I'm consistently moving towards 'the goal of becoming a great programmer'. I want to have a sense of 'working towards the goal'.

What I feel right now is more like "I'm coding stuff which is a lot of fun and I'm improving, but I don't feel like I'm 'making progress towards my goal'".

"Slightly improving over time because I'm coding stuff" doesn't really feel like "making progress towards a goal".

To those of you who are experienced developers: what advice can you give me on making consistent progress towards the goal of becoming great at programming, as opposed to just coding stuff for fun?

  • 6
    The answer is simple: always be working on something that is currently too difficult and is outside your familiarity zone. Apr 26, 2014 at 22:56
  • The questions you've been asking put you way ahead of the game. Don't sweat it -- you have lots of time to build on what you've got already.
    – sea-rob
    Apr 27, 2014 at 2:17
  • 1
    Have other enthusiasts and professionals review your work. You'll learn much faster with someone experienced looking at your work. I'll just leave this here. codereview.stackexchange.com
    – RubberDuck
    Jun 8, 2015 at 11:34

6 Answers 6


Don't knock coding for fun. The key thing needed to become a great programmer is to actually program. Once you get into college, and eventually business you'll find that very little of school and work involves actual programming. Having the passion for it alone goes a long way.

The other big part of it is reflection. After you wrote code for fun (or in the middle of it if it's lengthy), take a moment to evaluate what you've done. What went well? What sucked? Why were things good/sucky? How can you do more of the good things and less of the sucky things?

And then go code something else fun and interesting.


Incrementally expand your breadth and depth of experience, e.g.:

  • Read parts of the Java Language Spec, the VM Spec, and Effective Java. Programmers should know about things like "precise exceptions," the fact that reading or writing a pointer is atomic, and how to use wildcard generic types.
  • Write programs in various domains like mobile apps, web sites, robotics, and development tools.
  • Learn more programming languages, say, JavaScript, Smalltalk, and Clojure.
  • Deliver software to users. Do additional releases, making it better for them.
  • Write a program with other programmers. Use source code control (e.g. git or svn).

Above all, code. Code lots. And reflect on it. That's how you learn to value other things, because you feel the pain that leads to a motivation for a solution. While doing that:

  • Work with other people on projects
  • Learn from people better than you and be humble
  • Learn to value the parts that are not strictly coding but rather help with quality
  • Get perspective from other programming paradigms and languages

In other words, some of the best ways to become a better programmer are not new coding techniques per se. Similarly, they're not things you learn in college either. So let's break it down a bit more.

Regarding #1. As an observation, you will likely be working on a team in the future, but for many things you likely are not working on a team now given that you are in high school. Working on a team means a few things: tolerating other people's coding styles, other people's designs and architectures, Bob's bad taco breath on Taco Tuesday's, submitting code to a repository, having a build server, and having other people hate on your beloved code. Things you can do now:

  • Learn about a source control system. Use one for your personal projects. I recommend Mercurial or Git. Learn about and use branching; branching is not just some shiny concept it's a real tool in making sure code produced by a team is stable when it reaches production.
  • Set up a continuous build server of some sort. This won't take that long. Use this build server with your source control for one or more of your projects.
  • Buy gum for Bob.

Regarding #2. Find people better than you to learn from. This may be hard in high school. Look for people that are humble, don't routinely spout specifications, avoid flame wars, and are respected by others. Then read their code and watch how they interact with people around them.

Regarding #3. Learn what unit tests are if you don't know and why people write them (hint, it's not only for correctness of code). Learn a testing framework like NUnit etc. Find out how mocking can fit into (but is not equivalent to) unit testing. Understand what it means to write testable code - this tends to also be more modular and have better architecture too. Even though they are not always appropriate, understand dependency injectors/dependency injection. I write C++ daily without a dependency injector but the concepts are still applied from time to time in my code and it makes it better.

Regarding #4. Learn categorically new ways to program things and approach problems. This will probably make sense do do once you know Java well. It's like learning about programming patterns: learn it after you've done a bunch of programming (>10K lines of code) so you can really feel their worth and recognize patterns you've already done. Similarly, other languages' paradigms can help you in your current language sometimes because you may simulate a portion of a concept to best solve a problem. It also doesn't hurt to study a bit of history here.

Also, as a bonus: learn how to communicate your ideas well. I had much frustration for many years because I was poor at communicating my ideas and they were stuck in my head. This takes practice and perseverance, but frees you from being alone with your ideas.

Most of these things you will not learn in college. You will learn about algorithms, theory, perhaps the software engineering practices flavor of the month. But these things (with the exception of which source control is the current flavor, the concepts remaining similar) will hopefully change less and help you more. That's not to down on the theory, just to supplement it. I've written a couple state machines in the last week or two.


I would suggest taking advantage of the software community in your area. Look for a user group or software craftsmanship group that meets regularly and does pair programming exercises. Pairing with talented developers will definitely improve your skills faster.

If you don't have a local group you can still find developers to pare with online using screen sharing. Find a project on Github that interests you and ask one of the developers to pair with you on fixing a bug or creating a new feature.

Getting involved in the community will also have benefits outside of improving coding skills. Improving communication and collaboration skills is as important if not more important to become a great developer.

  • Work on a unix platform. I worked on Unix for 1 year in 1999 before returning in 2010. I should have never left. Compare your skills to others either locally or online to judge your progress.

  • Use VI and avoid IDE's They are a knowledge sink that will expire. This is one of the intangible items

  • Buy programming books and set goals to read chapters in x days/weeks and make sure you read the books completely. See
    If you could only have one programming related book on your bookshelf what would it be and why? for a good list. Mark your progress by pages / chapters / books - whatever you prefer to track that helps you keep going.

  • Buy programming books in an online format, e.g. a Kindle and set goals to complete them.

  • get good at using your development environment on your OS. It is your toolset. Learn how to customize it and use the tools and functions available. This will pay off constantly, not be a goal in itself.

  • Use code analysis tools, e.g. Fisheye. More details at https://stackoverflow.com/q/60394/631619 This will give you feedback on the quality of code and help you improve.

  • find ways online to work with other programmers to share and compare your self to millions of others.

  • recognize that this learning will be life long. Have a mind set for the long term.

  • consider setting yourself goals on Stack Exchange Sites. I set a goal of 1,000 badges across the network and I'm at 972 right now.

  • While there is nothing wrong with working on unix /Linux (and I would recommend having the skill) I don't think its a requirement.
    – scunliffe
    Jun 8, 2015 at 11:57
  • Never let your skillset become stagnant - always be pushing into new areas you are unfamiliar with.

  • Continue making projects, because an active understanding of something is far better than a passive understanding.

  • Pick up new tools, learn new languages, apply new ideologies, get into new areas. Dive into the deep end.

  • Make bigger and more complex projects each time.

  • Write something with one more person, then maybe two or three other people.

  • Expose yourself to the programming community - read blogs, follow news, check link aggregators.

  • Write tons of code. One of my favorite quotes about writing applies to programming, too: "Everyone has a million bad words in them. Only once they've written those million words can they start writing well. So get writing!"

Not the answer you're looking for? Browse other questions tagged or ask your own question.