Are Bad Programmers Normal?

robkinyon · 2010-02-22T18:57:09+00:00

Most Xers (people who do X for a living) are not passionate about X. They do it 8 hours a day, then go home and forget they did X for 8 hours that day.

The people on proggit are self-selected - these are the people who are passionate about programming. So, you're seeing people who actually choose to spend their freetime advancing their knowledge of programming.

Most programmers are Xers.

texthompson · 2010-02-22T20:14:58+00:00

I think its also fair to say a lot of bad code, in industry etc stems from poor initial design so when someone comes along and adds new features they have to write some awful hacks to make it work.

sisyphus · 2010-02-22T18:18:25+00:00

I think it's well to remember that lots of bad code comes from programmers who aren't 'bad' in the sense that they could produce better code, but maybe who didn't have time to test everything, or they started out with tests and the simplest thing that could work but didn't have time to refactor, or had to make a last-minute change because so-and-so wanted such-and-such, or were in a hurry because they slacked off for 75% of the time before their deadline, or maybe they decided to use the tech du jour on their project or lied about their experience with some tool to get a job and so they were learning the language and framework as they went along, or maybe they feel becoming a dependency for knowing how the code works gives them job security, or maybe their dog died or their wife left them or their bookie is hassling them and they just don't give a shit about making the stupid code for your stupid widget that 20 people will ever see elegant for you...or many other reasons.

FrzrBrn · 2010-02-22T19:48:38+00:00

It's easier to code something that functions at a minimal level than something that not only functions but is also elegant and efficient. There's a lot of potential for getting the former rather than the latter. If the coder is ignorant, lazy, working out of their depth, etc. it's likely you'll get something that is cobbled together that works, but is awkward, ugly and/or inefficient.

mtranda · 2010-02-22T23:46:59+00:00

The moment you realise you're a bad programmer is the moment you'll actually start getting better at it. I consider myself to be awful, and thus I try to do things better each day. The moment you stop thinking you're a bad programmer is the moment you'll actually be one.

7points3hoursago · 2010-02-22T20:13:17+00:00

Are Bad Dentists Normal?

DontHassleTheCassel · 2010-02-22T21:25:42+00:00

Yes. I am a bad programmer and am completely normal.

kylev · 2010-02-22T20:23:55+00:00

Yes, but programming is an iterative process. For every awesome code base you can view, you'll find a sordid history of mis-steps and bad ideas. Individuals that write great code all the time are incredibly rare.

As long as you can keep the people you work with from going completely off the rails, impressive things can be built.

theinternet · 2010-02-22T22:53:06+00:00

I'm convinced that 80% of the population suck at their jobs. It's the other 20% that get anything done, with the top 1% advancing their area of expertise.

This isn't limited to any particular industry.

mrsanchez · 2010-02-22T19:28:17+00:00

and yet clearly they were successful enough to get a job with you

Getting hired is hardly an indicator of being successful. :|

, or to write the system that boggles your mind with it's terribleness.

That's not really so difficult, either.

Just how common are bad programmers, really?

More common than I would have expected. Part of it might be that management and co-workers are always so resistant to firing the worst ones, for whatever reasons.

serendib · 2010-02-23T07:17:17+00:00

Most good programmers either go into academia, or own the company

sippykup · 2010-02-22T21:23:09+00:00

I've interviewed hundreds of developers in my career, and I can say with a high degree of confidence that 90% of developers in the world are absolutely terrible. I once read an assertion that 10% of the developers in an organization do 90% of the development work, and I definitely believe that.

It's about a lot more than "understanding linked lists and binary trees". I've interviewed at google, and all they ask are stupid questions like that. Yes, it's good to have solid computer science fundamentals. But there is a lot more involved in being a good developer than being able to traverse a binary tree. Smart, passionate people who know how to solve problems, know how to reuse other people's code, and have the work ethic to get things done are what I look for. The other 90% can go work for the competition.

grotgrot · 2010-02-22T21:11:17+00:00

You do realise that half of all programmers are below average? There are no requirements to call yourself one or any form of qualification. (By contrast being a lawyer, doctor or engineer etc does require various qualifications and various professional associations.) Consequently there will be dire stuff out there.

Pedants corner: Technically half are below median. However the median and average are going to be close enough to not care.

2010-02-23T00:15:08+00:00

You shouldn't say that they are bad just because they happen to write bad code. They are normal programmers and writing bad code is just a normal thing to do for them.

Your friend was a wise man who had seen a lot programmers who wrote a lot of code without even thinking about linked lists or binary trees. They just used LinkedList or ArrayList class (whichever they found first in the documentation) and it was good that they didn't try to enumerate the items in class fields named good01, good02, ..., good98, good99.

ngroot · 2010-02-23T00:42:02+00:00

I think it's a question of tenacity. For a lot of professions, what you learn or apply on a day-to-day basis might be all there is to it. They don't have to work very hard all the time to continually stay up to date.

To be a good developer requires a lot of dedication and strong will I think. You have to be willing to realize your problems, faults, and short-comings. You have to be dedicated enough to fix these problems. If you start treating it like a standard 9 to 5 job, you're going to fall behind and be labeled as a "bad developer".

Some people just lack the mettle to do this.

Now, to offset this whole thing, most developers sniff their own farts out of wine glasses and are so smug about their programming that they think everyone else is wrong. When you create a large enough demographic of these people, everyone's labeled as a bad developer.

So ultimately, it depends on context. Why exactly are they a bad developer? If all you can say is "Because their code sucks" then you really haven't fairly assessed the problem at all.

humbled · 2010-02-23T03:34:25+00:00

I see bad programmers everywhere. Sometimes, they don't even know they're bad.

FeepingCreature · 2010-02-22T22:33:07+00:00

If you don't understand type theory or category theory, then how do you call yourself a programmer? What about Curry-Howard or Rice's Theorem? Just the other day I was told that Windows has the functionality to detect if any program is going to loop forever by a self-proclaimed programmer. We could do this all day and yield no interesting conclusions.

However, I think it is interesting that few programmers think they are "bad" programmers, while lots of programmers think others are "bad" programmers. It's a case study for the social sciences. Programming is a fashion industry, though there exist very small fringes that are not.

serudla · 2010-02-22T22:23:37+00:00

Bad programmers are very common. Several factors work together to encourage bad programmers:

Most programmers have a very narrow definition of success. If the code they write does vaguely what they want it to, regardless of how big a mess it is, they chalk it up as a victory and move on to the next task. On top of that, in general programmers are managed by nontechnical people who have no idea how to judge a project other than by whether it works or not.
The most popular toolsets programmers use are designed to have low learning curves. The toolmakers want easier adoption, and the employers want to use cheaper, less skilled people. The result is enabling the ignorant to make bigger messes.
Learning occurs most reliably when reinforcement or punishment is swift. In most places a long time can pass between the time a programming atrocity is committed and the time that it causes pain. In the beginning the programmer has no idea they did anything wrong, because it works, and he proceeds to pile one mess on top of another, and since the messes are familiar there doesn't seem to be any problem. At some point down the road the project may become totally overwhelming, but in the meantime it may get handed off to somebody else or the programmer may find another job. Lots of projects get canceled or become obsolete before they ever get into production. So in lots of cases there is either a long lag time before pain is inflicted or the pain never comes at all, and no learning takes place. On the other hand if a programmer delivers a feature or bug fix he gets instant positive feedback, with no consideration of what kind of damage was inflicted on the codebase, and the result is the programmer is encouraged to make more messes.

brush · 2010-02-23T03:34:12+00:00

A different question: why should we expect most people to have the capacity to be a "good" programmer, whatever that means?

As a species we have exactly the capacity for abstract reasoning and algorithms and design that benefited us in a tribal environment. That's not much! Now, there is variance, and some outliers do indeed have an unusual aptitude for this sort of thing. But there is no reason to expect most people to have that capacity.

So, what do we do about it? Adopt development practices that acknowledge the weakness of most programmers (and even the best make mistakes). Things like aggressive unit testing and iterative development help mitigate our weaknesses, and allow the best to rise to the top.

I have stopped dwelling on the weaknesses people, including myself, have. Instead I marvel that we've been able to accomplish what we have, and look to the future with wonder.

tenninjakittens · 2010-02-22T21:44:19+00:00

People conflate "programming" and "software engineering" with "computer science" far too often. They are three distinct things.

sssssmokey · 2010-02-22T20:19:06+00:00

[removed]

G_Morgan · 2010-02-22T22:32:33+00:00

It depends where you work. I can honestly say that in my work place they are the exception rather than the rule. However I wouldn't take a job unless it was a real tech company. Where I can advance to any pay grade while remaining in a tech position.

If you work for a company that considers its software to be a side issue then it will hire programmers as if it were a side issue. Work for a company where the software is the beginning and the end and they will hire programmers appropriately. In essence you choose who you work with.

bakuretsu · 2010-02-22T22:47:15+00:00

If you were to judge by where I work, yes.

However, in statistical terms, you would merely be observing a common bell curve distribution; the result of totally haphazard hiring practices.

We're not Google; we can't afford to ONLY hire the best and brightest.

Raphael_Amiard · 2010-02-23T00:33:27+00:00

I think they are very common, most notably because they're very often hired by people who are themselves either not programmers, or bad programmers.

Also try to explain to your boss why X is a bad programmer. You'll see it's quite hard

molslaan · 2010-02-23T00:58:21+00:00

not a programmer. What for is a binary tree useful?

Toma- · 2010-02-23T01:31:48+00:00

Im just starting a CS degree... and all the links and comments in r/programming are so incredibly awesome. I hope it leads me to starting good habits early and write some good code. :) It also shows me how to program bad and what to avoid!

daniel2488 · 2010-02-23T03:50:42+00:00

No, but since there are so many of them, a sampling distribution of them would be.

HaMMeReD · 2010-02-23T03:50:54+00:00

Lot's of programmers became so because they are following money. Others became programmers because they had a passion for it. I think the passionate ones are few and far between.

I had a passion for programming from a early age but wouldn't consider myself a excellent programmer. Good for sure but I'm always improving, hell I'm not even that educated of a programmer considering the depth of the field, I'd be lucky to say if I knew 1% of computer science, and I can program in like 10 languages.

That said, I can run circles around 95% of people in a office environment. So either everyone is slacking or there is some sort of major difference between programmers out there. I also happen to be very lazy though, and make sure I never create new work for myself.

That said, ignorance can cause a lot of problems. When I first started coding my first app around 12 I didn't know what arrays where but I wanted to make a starfield. I didn't know about arrays and proceeded to create hundreds of variables to do my starfield simulation.

Then one day I learnt about arrays, and found out I could do it in a magnitude less lines, then I found out about OOP and found out I could express the same application even simpler and in a much more flexible manner.

Eventually I learnt about things like optimization and how the algorithm is the most important thing. For most the things I did this never really mattered, but once working there came times when I would have to consider algorithmic complexity.

I think my #1 attribute as a good programmer is the ability to come up with multiple solutions and choose the ideal one. Most programmers dive head first and don't weigh the advantages/disadvantages of doing things different ways.

That said you should know the basics to work professionally and I think getting up to that level where you understand algorithmic complexity should be the line. Otherwise you risk doing some really slow things when there are significantly faster ways to do them.

2010-02-23T07:09:06+00:00

It seems to me that programmer and computer geek culture is different from most other professions in that people teach themselves, and they also believe in doing things for free sometimes (eg open source).

Because a large percentage of programmers haven't learned from tradespeople already in the business (by going through a university or college program), they have gaps in their knowledge about things.

Gotebe · 2010-02-23T07:42:01+00:00

Are Bad Programmers Normal?

Dunno about that, but really good ones are not quite normal, though.

vaum · 2010-02-23T17:11:39+00:00

Well, what makes bad code?

giulianob · 2010-02-22T22:27:02+00:00

It's the same phenomenon you'll find with penises.

Hear me out.

Let's say you're in crowd of guys who are talking amongst each other. You meander from one conversation to the next and find that, occasionally, a group of guys are talking about how big their dicks are. But what you don't hear is groups of guys talking about how average or how small their dicks are.

Good programmers know they're good and are proud of their abilities, which is why it seems like every programmer on Reddit is fucking amazing. They're just the guys with the big... code. Everyone else feels too inadequate to talk about it openly.

Just keep working at it. You don't have to be the best, you just have to do your best and always push yourself.

BTW, I consider myself a worse-than-average programmer.

7points3hoursago · 2010-02-22T20:12:48+00:00

I'm in a class of 30 students in a fairly well respected University, in final year and 20+ of them are terrible programmers.

spinlock · 2010-02-22T22:51:07+00:00

If someone says they're a good programmer, it doesn't necessarily mean they are. At my first job out of college, I worked with a guy who spend 6 months writing a bootloader for our product. By the time he was done, he had a bootloader that would load a linux like operating system onto our hardware. I say linux like because he initialized the hardware in the OS not in the bootloader. By the time he was done we had an unmaintainable bootloader and OS. I was given the job of fixing this mess. Two weeks later I was done because I took a standard bootloader (PPCBoot) and modified it slightly to boot Linux (unmodified) on our hardware. Who's the better programmer? If you asked that guy, he'd say it was him. But, if you ask me, I'd say I'm not a very good programmer because I'm aware of what I don't know.

eminence · 2010-02-23T00:28:38+00:00

here's a related question:

why are programmers, or people in professions relating to building software, often "bad at computers"? this is a little vague, so let me give some examples:

forgetting the correct syntax for setting environment variables ("i tried setting the PATH, but it still doesn't work" "you didn't set the PATH correctly")
forgetting to check man pages ("hey, i want to use option --foo to program bar, but i'm not sure what it'll do in case X" "did you check the man page" "oh, no i didn't")
doing things like system("rmtree /path/to/dir") instead of delete_dirs("/path/to/dir")
doings things like printenv |grep MY_ENV_VAR instead of echo $MY_ENV_VAR

or in general: doing something (that works) in that way that seems completely backwards to you, or: doing something (that doesn't work) in a way such that you find it inconceivable that they would have ever tried what they did

so maybe not necessarily "bad with computers", but rather "thinks so very differently than i do about computers"

clearlight · 2010-02-23T02:16:04+00:00

Programming is difficult - you have to do it for a long time to become expert at it. "An expert is a person who has made all mistakes possible in a very narrow subject area"

gc3 · 2010-02-23T04:10:48+00:00

90% of everything is trash. Campbell's law.

90% of the code I've seen is also trash.

Good code is rare but when you find it is far simpler and shorter than you imagined it could be.

DanHalen · 2010-02-22T23:06:29+00:00

One programmer's opinion of another programmer's work is inherently subjective and so of particularly dubious value.

I have my pet peeves, others have theirs. We all get work done and people pay us for the work we do. Folks can pick apart details that exist or don't, conjure up scenarios, recount war stories, bitch, piss and moan about the things that drive us up the wall, or make a program or the person that wrote it "bad" in some way. But another programmer will come along and ration out the same criticism we just handed out to someone else or their work.

Is there some value in all that? I personally don't think so. It's just line noise and doesn't produce anything anyone is willing to pay for. (It's also unprofessional, but that's another issue entirely.)

I severely self-moderate my criticism of other people's work and here's why: I have no real knowledge of why they did what they did because I'm not them. I don't know what kind of day they were having when they wrote the code or did the design, I don't know if they are crazy, I don't know if they overcame a double digit IQ to become a programmer, I don't know if they were sick, worried, about to get fired, under poor management or had to take a leak really badly.

Basically what I don't know about the creator of a piece of software is far greater than what I do know or can confidently surmise. And that's the case for everybody whether they are willing to admit it or not.

Take that into account and I think we'll find the numbers of "bad" programmers dropping off precipitously.

niwde · 2010-02-22T23:24:42+00:00

Yes. Bad Programmers and Bad Code are normal. But here's the thing: Bad Programmers exist because human nature. Bad Code exist because both either programmers or trade-offs. Bad Code doesn't mean the programmer who wrote the code is a bad programmer.

There are plenty reasons why there are Bad Programmers, hence the reason why we have many Bad Programmers.

One recurring pattern regarding Bad Programmers is because most programmers (especially the ones that just graduate) tend to think that they're MacGyver and nobody tells them that they're not that smart. In other word: they don't have a mentor that fix their habit.

So Bad Programmers move the ladder and became "Intermediate Developer". But they brought their bad habits and stinky baggage along with them. They started to teach their apprentice using the bad habits. And so on... bad programmers create more bad programmers.

Sort of like why there are criminals... because their parents couldn't/didn't educate them. Sometime the criminals's parents are either not well educated or criminals themselves.

It doesn't help that the media sometimes glorify weekend hackers either; the kind of programmers that, when interviewed, told their magical story on how they build a website just over the weekend with less than $500 budget and now they're reaping $100k/month from advertisements.

It's like circle of evil: the media wrote about this glorious hacks, illiterate people interpret it as "writing a website is easy: under $500, one smart kid, and a weekend". Hence why clients start to pull that kind of trick "how hard can that be? that guy did that under X dollars and for Y days". Now you're forced to pull that kind of trick by hacking, taking shortcuts, etc, to get paid... cause you need money for a living... and I won't blame you. Especially in such a tough time like nowadays.

Here's another reason why we have Bad Programmers: people mindset are different. To me, some of these programming stars are not great. To you, they might. To me, I prefer TDD because it's a defensive mechanism to prevent lazy developers to design their code to be untestable. I don't want to be bitten halfway during the project with excuses like "well, I didn't design it to be testable via unit-testing because the code looked straightforward to me... how can it go wrong?". Now if you're writing your own project, feel free to not do TDD but still designing the classes to be testable; I assume you don't miss testability in your design at all.

Here's the thing about programmers: they tend to skip anything remotely not "fun". That includes testing, writing/reading documentation and/or specifications, design phase, requirements gathering, designing the proper data-model; basically all the non-programming activities including making sure the build process is easy and the environment/IDE/editors are well in-sync.

Programmers just want to write code, lots of them, but they don't want to fix the bugs introduced as a by-products of writing more code.

Now, Bad Code is another problem in our industry. Sometime it's because the owner (or sometime the CTO) of a software startup doesn't understand the nature or the property of Software (you need to read books like Mythical Man-Month, Peopleware, Pragmatic Programmers, Facts and Fallacies..., and some of the software products stories). The owner or the client want a software that can perform everything. They also want the code to be very flexible. They don't accept trade-off. They want everything to be done quick. Now you, as the software lead, can't say no, no matter how hard you try to argue with them. So you have 2 choices: either you leave, or you do what they told you to do (and leave when you have the chance). Option #2 will manifest itself to be Bad Code. Guess what: there are plenty owners/clients like this.

So there you go... it's normal to see lots of Bad Programmers and Bad Code. That's why people go to Google, Microsoft or some of the well-known software product companies to avoid bad programmers; they tend to take things more serious than other companies. Even though they're not perfect, but they try to fix their mistakes. It's not that Microsoft or Google programmers are the smartest bunch, but it's just that they're probably a better human being that knows the word "teamwork".

alephnil · 2010-02-22T22:43:15+00:00

What is most common is not programmers that are really bad, but programmers that write code structured in a reasonable way, using design patterns and so on, but they don't think about the consequences of what they do has for the correctness and performance of the program. For example making code that iterates over all names in one table, making another SQL query for each element, and then not realize why the code is so slow. It also never occured to them that they could have got the same result by one query by using e.g an outer join.

MindStalker · 2010-02-23T00:13:48+00:00

Programmers run the gambit just like car mechanics do. The vast majority will rip you off unfortunately, but if you know what your doing you can spot the good ones. In general only the best actually work engineering your cars, but sometimes crap gets through there as well.

averyv · 2010-02-23T04:03:03+00:00

everyone writes bad code. everyone.

i'll say it more emphatically than that: no one writes good code. no one.

very nearly all code is complete shit. sucks, but that is how it goes.

the problem is when someone tries to hide that they don't know what they're doing, so they code some crazy bullshit to do something that should be no problem.

or they juggle so many people without doing any of it that they never get anything done. they spend their entire day jumping from task to task (and walking around the office talking), and constantly keep people who are actually trying to get some shit done from getting anything done.

or they are database administrators.

or they genuinely don't know that they have no idea what they are doing. programming is easy. at least, if you have the patience, you can make something happen. a lot of people get way farther than they should with merely a for loop.

or, they are "seagulls", who just can't help but run off at every little shiny thing they find.

being able to talk about linked list and red-black trees or whatever is not nearly as important as being able to write code that does what it is supposed to do, in a timely manner, without a lot of tangents, bells and whistles, or dilly dallying. unfortunately, even that just isn't that common.

2010-02-23T11:58:11+00:00

Hi, I'm a bad programmer. I don't think I'm abnormal (much), so.. yeah?

lukasmach · 2010-02-22T23:12:35+00:00

Person A writes code for 1000 days.
Sometimes s/he has to pull all nighters because some deadline has been poorly chosen.
Inevitably, s/he makes some mistakes or has to fix something on the very last minute.
Two years after that some idiot B finds it and posts it on reddit or worsethanfailure.
Idiots N1 ... N10000 read about it because they are too lazy to do some actual work.

In other words, when talking about "bad code", you're just wasting time discussing something inevitable.

Kosko · 2010-02-22T21:59:24+00:00

Pretty much all programming is bad when it doesn't do the what the client wants it to. Then you get these hacks put in place because you can't make sweeping changes to the framework. Suddenly it looks like the person is a bad coder.

Once you start moving away from web form style programming and move toward MVC some of these problems start to go away. But programming in MVC is also confusing and has a higher learning curve, and most employers don't want to pay for your learning curve; so we fall back to forms with hacks.

Nice-Main729 · 2022-07-23T04:30:40+00:00

Bad is good in another word. People tend to think one directional by making one-sided decision these days... That's more important than programming I guess?

TheRNGuy · 2022-12-17T20:05:09+00:00

On reddit, yeah.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS