Background: I am entering college next year. I really enjoy making stuff and solving logical problems, so I'm thinking of majoring in compsci and working in software development. I hope to have the kind of job where I can work with implementing / improving algorithms and data structures on a regular basis.. as opposed to, say, a job that's purely concerned with mashing different libraries together, or 'finding the right APIs for the job'. (Hence the word 'low-level' in the title. No, I don't wish to write assembly all day.)

Thing is, I've never been the most logically-sharp person. Thus far I have only worked on hobby projects, but I find that I make the silliest of errors ever so often, and it can take me ages to find it. Like anywhere between three hours to a day to locate a simple segfault, off-by-one error, or other logical mistake. (Of course, I do other things in the meantime, like browsing SO, reddit, and the like..) It's not like I'm 'new' to programming either; I first tried C++ maybe five years ago.

My question is: is this normal? Should a programmer with any talent solve it in less time? Having read Spolsky's Smart and gets things done, where he talks about the large variance in programming speed, am I near the bottom of the curve, and therefore destined to work in companies that cannot afford to hire quality programmers?

I'd like to think that conceptually I'm okay -- I can grasp algorithms and concepts pretty well, I do fine in math and science, although I probably drop signs in my equations more often than the next guy. Still, grokking concepts makes me happy, and is the reason why I want to work with algorithms.

I'm hoping to hear from those of you with real-world programming experience.

TL;DR: I make many careless mistakes, should I not consider programming as a career?



mashing different libraries together, or 'finding the right APIs for the job'

That's not what a programmer does. That is part of getting a job done, but anyone just 'mashing' anything together is not crafting a program.

Speed and accuracy are obtained by one thing: practice. I started programming in Python and other higher level languages. I then quickly moved to C. Learning C showed me up as the no-good, dirty scripter I was ... so I practised and wrote more complex code and got better.

Speed of debugging relies on intuition to spot the characteristics of an error, which comes from making many mistakes (like off-by-one errors). These mistakes get less trivial as you get better and your code gets more complex.

Like many things in design, it is perfect when you have nothing left to take away. APIs and Libraries are great ... that's what sharing code is about ... but nothing is as sweet as a small, perfectly formed bit of C that has grace and purpose.

practice makes perfect, and perfection is rarely attained. So keep practising. Also try and learn some fundamentals about why languages are the way they are (automata, syntax analysis) and why data structures are useful. It will make you better.

Wow, didn't mean to write that much.

From the comments:

Worried Programmer: Perhaps I didn't express the distinction with the right words.. for me a 'high level' job would be writing a web portal with e.g. django, whereas 'low level' would be writing a compiler.. I guess problem-solving is involved in both, but the theory-API balance would be quite different.

Aiden Bell: As someone who has written both web stuff and compilers, I agree. But you can be a good (or bad programmer) and make progress with both. Difference is, a good programmer will do both well, and understand the finer points and approaches of each through good theoretical foundations and an understanding of the nature and patterns involved. These things you get by learn, apply, make mistakes, repeat


A friend of mine happens to be just like you. He is a talented person who sometimes makes silly mistakes but he happens to be a great programmer.

Gaining experience will make your carelessness go away. Trust me, if you like programming, math, algorithms and etc then you are on the right track. You'll be able to be a great programmer once you increase your experience and knowledge.


"I make the silliest of errors ever so often, and it can take me ages to find it."

That's the day-to-day job of every programmer I know.

I an quite disorganized, lazy, forgetful; my desk is messy. Yet with computers and code, I have my distinct, very sharp desire for what I'd call "neat". And programming puts the bread (and the wine and the argentinean steak) on my table for over ten years now.

Spolsky's claim is to get the very best people by throwing copious amounts of money and creativity at this problem. You don't have to compete with the best, just with the good ones to survive in this industry. Code Complete has an interesting result from a survey: basically, the error rate is lowest for both the fastest and the slowest programmers; error rate peaks for the "mid field". Factoring in the cost of bugs, a slow but reliable coder isn't such a bad investment.

Learn to deal with your shortcomings. I know only too well how hard to track down this error is:

for(int i=0; i<outerLoopLimit; ++i)
  for(int j=0; j<innerLoopLimit; ++i)

After doing this once to much, I started to use completely different loop variables in nested loops. I never made this mistake again.

You kept yourself busy with hobby projects for five years - that suggests you have enough drive and motivation to find a place for you in development. I agree with the recommendation that you pick up some (discrete/analytic/reasoning) maths, that should help.

  1. Don't worry :) worrying won't do you any good anyway :)
  2. Assembly is cool (!)

But to answer your question, the ability to debug quickly and to find your own (and other people's...) bugs is an ability that can be acquired and improved with time. Everybody suck at it in the beginning.

I think that the most important thing for you is that you like what you are doing, and that you know that you can improve with time. So if it is your passion - I say go for it!

Good luck.


Practice makes perfect

No one is born knowing how to write code, it takes a lot of trial and error before you're able to write clean code out of habit. Its just like learning to play an instrument, or cook, or gymnastics, etc.

My question is: is this normal? Should a programmer with any talent solve it in less time? Having read Spolsky's Smart and gets things done, where he talks about the large variance in programming speed, am I near the bottom of the curve, and therefore destined to work in companies that cannot afford to hire quality programmers?

Yes, its normal for even experienced people to make entry-level mistakes.

There's some anecdotal evidence that suggests people who can't understand basic programming concepts from the start probably never will -- I don't buy it. At least in my experience, the "non-programming goats" (Atwood's words, not mine) are the same people who never write a line of code outside of school or work.

I've worked with programmers with 5+ years of experience who never get beyond the basics of CRUD apps. And I've seen fresh-out-of-highschool kids who, after years of coding as a hobby, upstage their 5+ year colleagues and interviewers. I consistently find that individuals who write code in their spare time, read/author programming blogs, post on StackOverflow are more skilled than individuals who don't.

I'd like to think that conceptually I'm okay -- I can grasp algorithms and concepts pretty well, I do fine in math and science, although I probably drop signs in my equations more often than the next guy. Still, grokking concepts makes me happy, and is the reason why I want to work with algorithms.

Try implementing this list of algorithms. (I personally find the immutable versions of tree-like data structures, AVL and red-black in particular, much easier to write than their mutable variants.)

Believe me, I've given plenty of interviews probing people for basic knowledge in algorithms. If you can write a binary search, sorting algorithm, linked list, and hashtable from scratch, you're already lightyears ahead of 99% of everyone.

should I not consider programming as a career?

bool considerNewCareer =
    worriedProgrammer.EnjoysProgramming() &&

Trouble with Joe? He only solves easy problems. Jack? Oh he solves tough problems, they take days to solve!

It's impossible to say how you compare with "good" programmers. Off by one errors are made by every programmer I've ever met. And if they manifest in subtle ways they can take time to find.

I find some very positive things in what you say:

  • You make mistakes, but you care!
  • You make mistakes, but you solve them
  • You enjoy thinking
  • You are interested and read around the subject.

As you undertake assignments at college I think you'll get a better feel for how you stack up. When you work to deadlines it does tend to focus them mind better than when working as a hobby. Don't give up the dream yet!


Just do what you do;

In school, you will be exposed to many new things you don't currently know and understand. You may learn simple working techniques that will completely eliminate what you perceive as your "shortcomings". Or not. The field of computers is vast, and there are many, many niches. Some people specialize, some people generalize, some people change specialties repeatedly.

So my advice to you is: Just do what you do. Do your best. And stop beating up on yourself so much. The one thing that will hold you back in life more than anything else: your lack of trust in your own abilities.


This is normal. Get your education and get experience, do what motivates you - that is key, that is where you will find success.

If you are interested in working with algorithms and data structures, then you probably want to go down the path of theoretical computer science.

Regarding your "careless mistakes". First step is that you actually acknowledge this is an issue for you (most people don't even get to this point). Since you are aware of it now you may try to change your habits and the way you work to minimize these kind of errors.

Careless mistakes may often be prevented using tools, everything from a lint checker to an IDE with better hints - but most importantly practice and experience.


A lot of programming guidelines come from painful experience. I've had to become more disciplined in my approach to development because I've had to endure debugging and code maintenance. Until you suffer maintaining someone else's code you're more likely to be carefree in your own development (much like a tourist walks new city streets with abandon until learning about muggings there).

I'd encourage you forward; if you enjoy algorithms then you'll enjoy the satisfaction of seeing them compute: then as you optimise them you will gain additional satisfaction. As you hit your head against brick walls of silly mistakes you'll change and this is part of becoming a seasoned developer.


I would suggest majoring in CompSci and either double majoring or at least minoring in Mathematics. Mathematics will help you with your attention to detail. Not only that but having that math experience on your resume will look good to any prospective employer. It means that you know how to learn and can grasp abstract topics. Plus math is just fun. If you really want to learn about algorithms. Math is where to be. You will need the math experience to be able to describe and understand their time and space complexity functions.


Cultivating a set of habits that prevent you from making mistakes does make you a more efficient programmer. After all, you want to focus on the real problem at hand and not minor incidental coding bugs.

However, I think most experienced programmers will tell you that making trivial mistakes including spelling, syntax, off-by-one, etc. errors are just common day-to-day errors that everyone will experience.

With regard to C and other low-level programming languages, you will find that over the course of weeks, months, and years, you will develop a strong set of skills that grow imperceptibly over time that will keep you from repeating certain kinds of mistakes and make you more efficient.

You may find that writing unit tests will help you, especially as the size and complexity of an application increases. Such unit tests may be difficult to write for applications that have dependencies on hardware and make lots of IO calls.

Finally, if it's low-level coding that you like, you might enjoy studying computer engineering more. You'll take the same core computer science courses that a computer science major needs to take, but you will also learn assembly and get a chance to code using assembly and the even lower-level Verilog and/or VHDL. You will have the opportunity to work much closer to the machine level in those classes. Your computer science classes will probably keep you locked up in Java land, unless you take (and I hope you do take) an AI class and learn Lisp or Prolog.


I assume because you're about to enter college that you're young. There is no way I could earn a paycheck as a programmer at the level I was when I was entering college. If you find building stuff with software interests you, you can learn the discipline and skills needed to be a professional programmer. All it takes is time, and a whole lot of practice.

See Outliers. Author Malcom Gladwell suggests that 10,000 hours is the amount of experience one must have to become an expert. Bill Gates became a software god because he learned to program at a time when there were no other established gods, and he had access to computers in high school and college (before he dropped out) that very few people had. He was able to amass 10,000 hours of programming experience when there were very few other people who had. It took Bill about 7 years, if I recall from the book correctly. At a more normal pace, it takes about 10 years of working 9-5 to amass 10,000 hours. I'm still working towards that, myself.


Make sure you know how to properly use a debugger. I cried the first day I figured out how to use gdb instead of doing printfs everywhere.

Strive for consistency in your code. If your working on a hobby project, try making a naming convention and such. Also, with C++ don't get too many operator overloads.

I don't know if it's normal to still be debugging very common errors for long periods of time after 5 years of programming(how often do you program in these 5 years?), but I know during my first year or two of C programming, usually I spent one day writing a new feature and the next day figuring out why it didn't work. I was a hobbyist back then though.


Make sure in college that you take classes with labs and projects, and have graded problem solving sessions. College is there mainly to teach you critical thinking. This is by far the most important takeaway from your B.S. More important than learning Java or calculus is the practiced ability to reason.

Problem solving comes from practice and experience. Being bitten by common mistakes is the only way to recognize them quickly!


Curious, nobody voted up yet you already have several answers. Obviously everyone is eager to give you their own experience, and not read others'. I'd better do the same! :)

Short answer: yes you're perfectly normal. If there was a perfect stereotype of a programmer, we'd all be unemployed. Because normality is, not being a programmer. Man, go for it. But - but - just keep a backup plan. Something that will save you when you'll be bored of being a programmer. Sport. Dancing. Music. Women. Eventually, that backup plan will make you a whole person. Until then, you're learning a job.

Have fun. And I mean it.

Now, off I go reading other people's answers


My suggestion would be to consider stepping back for a moment and look at the broadness that is whichever technical discipline you are studying at college. My guess is that you may not have done a lot of work in Numerical Analysis or Operating Systems which could be part of various Computer Science or Software Engineering curricula. So, firstly note the breadth that exists within the subject.

Secondly, could you refine what it is that you'd be doing that an employer would be paying you to do? For example, do you want to work in some university trying to find an algorithm in P for some NP-complete problem? Granted one could get a million dollars for such a solution, there aren't many companies doing that kind of work. Do you want to be in business intelligence or some other data analysis area where interpreting statistics is your daily life? Or do you want to be trying to refine how UPS or Fedex generate the routes that their trucks take each day? Understand that employers generally are paying well because the developers are producing something of value.

Just a couple of thoughts besides looking at all the other career questions on this site to see similar questions asked over and over again... here are a few examples: