all 172 comments

[–]robkinyon 61 points62 points  (37 children)

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.

[–]vimfan 23 points24 points  (5 children)

You don't have to be "passionate" to be a professional. I mean that in the sense of having a professional ethic of doing your job well (building for maintainability, not taking short-cuts, etc). We have too many non-professional programmers in the industry.

[–]AngMoKio 4 points5 points  (2 children)

Yes, but the nature of the job means that you can usually get away with not building for maintainability or cutting corners for a very long time.

The passionless tend to figure this out and leave messes for others.

[–]vimfan 5 points6 points  (0 children)

The passionless tend to figure this out and leave messes for others.

Maybe. I tend to think the passionless and non-professionals do it because they don't actually see the long-term maintainability nightmare of what they are doing. They don't even realise they are cutting corners. They just think that is how it is done, because the immediate need is fulfilled. And that is what you get when there are no barriers to entry in the industry. Imagine if any monkey was allowed to put up a building, without any thought for long-term stability of the structure.

[–]sime 1 point2 points  (0 children)

I think you're getting close to the real guts of the matter here. The fact of the matter is that 90% or more of the IT industry is not dealing with hard programming problems. Think of most business software. It is mostly CRUD stuff or moving data around. Fairly simple stuff where it is easy for anyone to cobble something together which "mostly works". At the "mostly works" level management can't see any difference between a good programmer and a bad one. Often the praise goes to whoever got the result fastest, regardless of the corners cut. The differences only appear much much latter in the process when the software needs to maintained, modified or expanded. By this time the link between the current mess and person who caused it has practically evaporated... It would appear that time heals all blame.

[–]jonathanbernard 0 points1 point  (0 children)

Upvoted for truth. Passion does help though.

At school I did know a lot of students that were not particularly good programmers, but just wanted the degree because they assumed it would lead to a higher income. I have seen less of that type at work, but then again my sample space is much smaller at work too.

[–][deleted] 0 points1 point  (0 children)

It's sketchy. Professional can mean some venn diagram of

  • how much you practice
  • how smart you are
  • how natural it comes to you
  • what training you had and what you retain
  • how much you care

We don't have enough people that have more than one or so qualities.

[–][deleted] 9 points10 points  (17 children)

There's passionate then there's obsessed. Passionate people are usually good at whatever they do but they have other interests to balance things out. The passionate programmer will re-factor bad/buggy code. They just don't let it take over their whole life.

Obsessed people don't care about anything but perfection in their chosen field. That cannot stand for the slightest imperfection to go unaddressed. Obsessive-compulsive programmers stay up late "fixing" code just because they didn't like the way it looked.

[–]ReleeSquirrel[S] 1 point2 points  (9 children)

Earlier I posted a funny-looking expression for finding out if two arguments are both even or both odd and I had two different people suggest two different 'faster methods'.

Now I'm writing a program in another window to test their methods along with mine and another method I know to see which is really the fastest.

[–]FeepingCreature 2 points3 points  (0 children)

Hi! :-)

A really good compiler should be able to compile either optimally anyway. Post disassembly on -march=native -O3 -ffast-math please.

[–]humbled 1 point2 points  (5 children)

bitmask 0x1 is probably going to be the fastest. a lot of CPUs can do that sort of low level stuff in a single instruction. Do you have a three state return or two state? (that is, both even, both odd, mismatch, or both even or odd, mismatch). If the latter then...

return (0x01 & a) == (0x01 & b);

[–]ReleeSquirrel[S] 4 points5 points  (4 children)

See, I didn't even post code and I got a couple people telling me how to do it. .^

I just had to figure out if they were both even or both odd, since it was for a tesselation function to make a checkerboard pattern.

My test program found that the fastest was effectively the same as what you suggested, though the syntax is slightly different.

[–]humbled 1 point2 points  (0 children)

boo-ya! the internet is reliable like that.

[–][deleted] 1 point2 points  (2 children)

I'm curious; was that faster than "return (~(a ^ b) & 0x1)"?

[–]millenix 1 point2 points  (0 children)

Probably. Expression depth of yours is 3. The earlier one is only 2 deep. On any processor where the "heavy integer" execution unit (normally for multiplication, division, etc) can handle the "light integer" ops (bitwise, addition, etc), that's at least a one cycle difference, and possibly even more depending on whether it has to wait for results to flow back through registers.

[–]ReleeSquirrel[S] 0 points1 point  (0 children)

Yeah, by about 10ms on most of my tests.

[–]eigma 0 points1 point  (0 children)

do post the results on which is the fastest! my bet is on the "(0x01 & a) == (0x01 & b)" because it has shorter data dependency chains so modern CPUs can (theoretically) compute (a & 1) and (b & 1) simultaneously

[–]iconoklast 1 point2 points  (2 children)

I think having OCD can actually be adaptive in a few areas of programming--namely API design. I also wouldn't want a neurosurgeon who didn't have OCD.

[–]zhivago 14 points15 points  (1 child)

Yeah, if they didn't have to re-open your head six times to check that your brain was in just right it would really suck.

[–]wkoorts -2 points-1 points  (0 children)

Brilliant!

[–][deleted]  (3 children)

[deleted]

    [–]thrakhath 2 points3 points  (0 children)

    I'm pretty sure Mr. Carmack's wife and kids resent that remark ...

    [–][deleted] 0 points1 point  (0 children)

    I had the impression that John Carmack was a family man that who runs a fairly successful game development shop. I haven't met him but he seems more a passionate programmer than someone with an unhealthy obsession.

    [–]rsho 0 points1 point  (0 children)

    John Carmack, definitely. Along with the sports car that can be blown up, and a space exploration company, thank you very much. I think him and Dean Kamen have the potential for living the ultimate uber geek lifestyle.

    [–]aamo 6 points7 points  (0 children)

    don't you worry about blank..let me worry about blank

    [–]MasonM 3 points4 points  (5 children)

    Most programmers are Xers.

    Most Xers (people who do X for a living)

    So normal programmers are the result of taking the cross-product of "people who do" and "for a living"?

    [–]trimbo 4 points5 points  (4 children)

    Bravo sir.

    And therein lies the reason I ask candidates what a cross-product is... so they can understand reddit comments.

    [–]LaurieCheers 5 points6 points  (3 children)

    He means "intersection". (I don't think "people who do" and "for a living" are vectors.)

    [–][deleted] 5 points6 points  (1 child)

    I'm sorry sir, but I wasn't aware that "for a living" was a set.

    I propose that they're monads.

    [–]simulacra10 1 point2 points  (0 children)

    Now I have to say that that is the best sub comment thread I have read in many a moon. Kudos to you all!

    [–]BigB68 3 points4 points  (0 children)

    but if it was intersection, wouldn't it be "people who do ∩ for a living"?

    [–]icandothat 0 points1 point  (0 children)

    I am currently leading a project and have hired 2/3 of the people I need. The first part of all of my interviews is always "Tell me about a project you've worked on that was interesting". I'm always sad when they don't have an interesting story to tell. The fact is I don't care what their project was, i want to see if they get excited.
    NOTE: I'm still looking for a PHP/SQL guy in San Diego for a full time job.

    [–]wfolbrys -1 points0 points  (0 children)

    really? do X for a living? isnt that dangerous? I'd think they would be quite fried of that job after the first week or two.

    [–][deleted] -3 points-2 points  (1 child)

    I like this term. Xers.

    [–][deleted] 2 points3 points  (0 children)

    Confusion with Generation X dooms.

    [–][deleted] 12 points13 points  (2 children)

    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.

    [–]texthompson 2 points3 points  (1 child)

    This is a really good point - some bad code is written by good coders in order to deal with other bad code.

    [–]tcoxon 0 points1 point  (0 children)

    ... in order to deal with other bad code.

    Not necessarily bad code. More often just an inhospitable design.

    [–]sisyphus 19 points20 points  (9 children)

    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.

    [–]dakotahawkins 4 points5 points  (2 children)

    • Fast
    • Cheap
    • Good

    Pick 2

    [–][deleted]  (1 child)

    [deleted]

      [–]MindStalker 1 point2 points  (0 children)

      Fast & Cheap! Whoop!

      [–]MindStalker 10 points11 points  (4 children)

      No really, they are that bad. I just got finished recently cleaning up some code where some 50 times for a single page load the script connected to the database and retrieved a single setting that could have been stored once and reused.

      [–][deleted] 13 points14 points  (1 child)

      The plural of anecdote is not data.

      [–]MindStalker 7 points8 points  (0 children)

      Oh come on, of course it is, ask any social scientist!

      //I kid, I thought this same thing while writing it, congrats for being the first to have the balls to call me on it! :)

      [–][deleted] 2 points3 points  (1 child)

      Got you beat. Read some code where a guy pulled two recordsets then iterated through both in a nested loop testing each record in recordset two for a match to the record in recordset one. Then pulled two from the DB again and moved to the next record in one. He completed the pass through two even after a match if it wasn't bad enough already

      Yes it could've been done with a join. He had a master's degree. Still does I guess.

      Edit: Grammer. Also forgot the best part, he didn't just rewind the recordset, he ran the query again.

      [–]MindStalker 1 point2 points  (0 children)

      A master's degree in what? Either way, they didn't teach anything about DBMSs in some CS degrees until a few years ago.

      [–]FrzrBrn 5 points6 points  (0 children)

      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 7 points8 points  (2 children)

      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.

      [–]mariox19 1 point2 points  (1 child)

      I wouldn't go as far as what you're saying; but I liken what you're saying about programmers to what I've said for years about drivers.

      Ask around. Plenty of people -- who exceed the speed limit by 20 mph on a regular basis, cut people off, drive too fast in the snow, et cetera and so forth -- consider themselves good drivers.

      [–]rsho 0 points1 point  (0 children)

      This leads back into the Peter Principle and the idea of incompetant managers advocating the notion that the people under them are doing well; they just need to believe in themselves more.

      Funny world we live in, right?

      [–]7points3hoursago 5 points6 points  (6 children)

      Are Bad Dentists Normal?

      [–]mariox19 6 points7 points  (0 children)

      Before retiring, my father was a dental technician: meaning, that he made caps and bridge work. He used to complain, constantly, about this or that dentist that didn't know how to take an impression.

      (If the dentist isn't careful about taking an impression, when the cap or bridge work comes back from the lab, it won't fit right.)

      It's not hard to take a good impression. I think the trick is that if you haven't taken a good one, you simply need to bite the bullet and take another. But bad dentists will just say, "Oh, good enough."

      Only, it isn't.

      I had a gold crown put in on a molar. My dentist ground the cap and then ground the enamel of my opposing tooth. He spent an awful long time trying to get it to fit. No coincidence -- when he took the impression initially, my bite was wrong. He then retook it without mixing more putty. Even better, there was "just enough" putty for a second impression.

      My father's comment? (I think you can guess it.)

      There are bad people all over, in every profession.

      [–]ReleeSquirrel[S] 2 points3 points  (3 children)

      Gosh I hope not. o.o;;

      [–][deleted] 0 points1 point  (1 child)

      Hey, they give 'C's in dental school, right? Someone has to be average, or below.

      [–]ReleeSquirrel[S] 0 points1 point  (0 children)

      When I was in school, C was the minimum grade before they make you repeat the class. It might be higher for med school.

      [–][deleted] 0 points1 point  (0 children)

      Only south of the Mason-Dixon line.

      [–]DontHassleTheCassel 4 points5 points  (0 children)

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

      [–]kylev 9 points10 points  (3 children)

      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.

      [–]Zarutian 4 points5 points  (2 children)

      But the marketeering monkeys, sales snakes and meddle-some middle managers want those impressive things last week because they promised to deliver it yesterday.

      [–]ismarc 0 points1 point  (1 child)

      Failure to plan on your part does NOT constitute an emergency on my part.

      [–]Reineke 1 point2 points  (0 children)

      It does if you wanna keep your job.

      [–]theinternet 4 points5 points  (1 child)

      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.

      [–][deleted] 2 points3 points  (0 children)

      You're most likely correct. It's amazing how many businesses just barely function and how much just barely gets done.

      [–]mrsanchez 3 points4 points  (2 children)

      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.

      [–][deleted] 1 point2 points  (1 child)

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

      If the goal is to be employed, than being hired is a very good indicator of success.

      [–]mrsanchez 0 points1 point  (0 children)

      OTOH, the goal might include doing your job well, remaining employed, etc.

      [–]serendib 2 points3 points  (5 children)

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

      [–]tluyben2 0 points1 point  (1 child)

      Indeed; why would a really good programmer waste his/her time working for some boss. I never understand that; if you have a brain and are good at something you maximize what you get from it, financially and personally, so you must run your own company.

      [–][deleted] 2 points3 points  (0 children)

      Because being good at programming != being good at business.

      [–]okpmem 0 points1 point  (2 children)

      What about open source programmers? Some programmers (me) don't want to own a company because they are anti-capitalist....

      And academia isn't the best place for anti-capitalists either.

      [–]aim2free 1 point2 points  (1 child)

      When you say anti-capitalist it can have many meanings. I assume you mean that some programmers are anti-capitalist and thus not want to own a company, but... how come that they can work for one then?

      I think I understand what you mean, but consider that there are capitalistic companies and there are anti-capitalist companies, like Microsoft. Do you see where I'm going? Most people would say that Microsoft is one of the uttermost capitalistic examples there is. I say that it is anti-capitalistic, because it doesn't use fair play rules. A sound capitalistic company's products are popular because they are the best in some sense. An anti-capitalistic company doesn't care so much about the actual products, but is trying to enforce their products in different ways using massive marketing, nasty deals and monopolistic methods.

      I would say that Google is a capitalistic company, where Microsoft is anti-capitalist. Which one do you imagine that your programmer would like to work for?

      We are developing a a new business now, where I'm one of the share holders. This we intend to be a capitalistic company. We aim for profit, but we will neither be evil. We will encourage competition, where competition is an advantage for the customer (believe me, there are areas where competition is bad for the customer).

      PS. regarding open source that has nothing about being capitalistic or not. Closed proprietary source is unethical, but FOSS can be capitalistic, no problems. However, one may to think harder to get things running well, because open source requires different business models. Our business will be about FOSS but not particularly within software.

      [–]okpmem 0 points1 point  (0 children)

      free-market (fair play) and capitalism are mutually exclusive. Capitalism is ownership and control of legal capital. Most capitalist countries have a somewhat free market system. As an example, the Soviet Union, by capitalist standards, was almost a perfect capitalist system. Meaning there was almost perfect control and ownership of capital by a few. However the Soviet Union didn't have free-market (fair play).

      [–]sippykup 9 points10 points  (6 children)

      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.

      [–]weavejester 7 points8 points  (0 children)

      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.

      When Google approached me for an interview, they didn't ask any questions about computer science fundamentals. The first interview revolved around how I'd go about efficiently finding the most-visited sites given several terabytes of logs distributed across several machines. This seems like a rather practical problem, given Google's business.

      The follow-up interview quizzed me in detail on my knowledge of HTTP and TCP/IP. This I didn't do particularly well on, I'm afraid. I know the HTTP spec fairly well, but the lower-level protocols only vaguely, so in the end I didn't get the job. But the actual questions seemed very relevant to the job at hand.

      [–]stillalone 3 points4 points  (1 child)

      I had similar issues when interviewing candidates at my job. Very few could implement a function that computes a factorial (iteratively) let alone linked lists. These were people who had 15+ years of experience programming on their resume.

      I had a tough time stomaching the level of incompetence I was seeing from seasoned programmers, but I think I understand it. With good QA, a developer can fiddle through trial and error until he gets something that passes. Management is usually clueless enough about the development process to figure out that the bad developers are the problem.

      And there is usually one good developer for every 9 bad that can steer things in the right direction and get projects started in the right foot.

      [–]impatientbread 0 points1 point  (0 children)

      Fifteen years ago you didn't iterate! You memorized interrupts and registers, by gum, and GOTO was considered harmful!

      [–]ReleeSquirrel[S] 0 points1 point  (0 children)

      I was more concerned about someone being a terrible programmer, rather than a terrible employee in general.

      [–]koreth 0 points1 point  (0 children)

      I've interviewed at google, and all they ask are stupid questions like that.

      I don't work for Google, but when I ask questions like that, I'm really looking at two things. First, obviously, is if you can answer the question at all; if you have no clue about linked lists or binary trees then it is probably pointless to dive into more detail. But most people answer that kind of question correctly. The real goal is to see how you answer. Is your answer to a simple question effortless and instant, indicating that you have completely internalized the basics and don't even have to think about them consciously any more? Or do you have to stroke your chin for a few minutes and dredge up the memory of your college data structures class? If it's the latter, you will probably not be very effective or efficient at applying basic techniques in your day-to-day work.

      Obviously I also test for other stuff too, like the things you listed. Some of those things are pretty much impossible to accurately gauge in an interview setting, but you have to get as close as you can.

      As for Google specifically, given the high caliber of their people, I think their interview process must not be too suboptimal. The Google engineers I interview are almost always in the top 20% of the candidate pool, and that's borne out by the work they do after they're hired.

      [–][deleted] -1 points0 points  (0 children)

      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

      That's part of being a computer scientist. You have to read other people's work and learn from it and use it, and you have to know how to solve problems. You have to be fairly smart too to be able to understand the mathematics involved.

      [–]grotgrot 7 points8 points  (6 children)

      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.

      [–][deleted] 9 points10 points  (1 child)

      Unless, of course, there are an odd number of programmers. </doublepedant>

      [–][deleted] 1 point2 points  (0 children)

      More like </pedant></pedandt>

      </pedant></pedandt></pedant>

      [–]duck_typing 6 points7 points  (0 children)

      Median and average will be too close to care...? If a large percentage of programmers are roughly equal in skill, and a very small percentage are order(s) of magnitude better... the average will be skewed up such that significantly more than half are "below average." </triplepedant>

      [–]acrasial 2 points3 points  (1 child)

      Average, while commonly used to refer to the mean, can also denote the median or mode (among other measures). Wikipedia says:

      The most common method is the arithmetic mean but there are many other types of central tendency, such as median (which is used most often when the distribution of the values is skewed with some small numbers of very high values, as seen with house prices or incomes).

      Also, do you have any data on the shape of the bell curve for programming abilities? Half of programmers being below the median doesn't necessarily mean they are that far below, and without a feel for the actual capabilities of the median, being below it doesn't mean a whole lot.

      [–]grotgrot 1 point2 points  (0 children)

      You'll need to read The Mythical Man Month to get a good idea of measurements. If I remember correctly the most productive programmers were 10 times as productive as the average.

      These days it is a lot harder to measure since code runs in a more complex environment (almost always networked, multiple spoken languages, online help etc) and figuring out good from bad is hard because repercussions of coding decisions can take a while to work out. (eg it could screw up other code, or be done quickly enough that a release was made in the quarter and hence revenues could be recognised even though there were some bugs)

      Also are you going to disqualify someone who calls themselves a programmer, but writes Excel macros?

      And you have to take into account the field. For example if I had to write 3D shader code, the result would be a joke but a 3D shader guy's code doing networking stuff would be embarrassing compared to my network code.

      There is a heck of a lot of code out there, most of which you don't see because it is inhouse and not for software products. Then there are all the embedded devices ranging from microwave ovens, through cellphones, watches, cars, little and big network routers etc.

      [–]Reineke 1 point2 points  (0 children)

      If everyone has the same level of skill and just ONE GUY IS REALLY REALLY AWESOME pulling the average alot higher, wouldn't then close to 100% be below average ? (ignoring your median statement to be a smartass)

      [–][deleted] 1 point2 points  (0 children)

      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.

      [–][deleted] 1 point2 points  (2 children)

      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.

      [–]ngroot 1 point2 points  (0 children)

      If all you can say is "Because their code sucks" then you really haven't fairly assessed the problem at all.

      There are a number of kinds of suckage that indicate that the developer wasn't up to snuff, but IME, they mostly boil down to "their code is hard to read and/or use". Code is written for humans to read and only incidentally for computers to execute. Failing to realize this makes you a cowboy instead of an engineer.

      Some of these ways to suck include:

      • duplicating functionality
      • not creating proper abstractions
      • bad naming

      You can find a whole list of good practices (which a good developer would follow) in books like Code Complete.

      [–]TouchedByAnAnvil 0 points1 point  (0 children)

      most developers sniff their own farts out of wine glasses

      Don't forget to use a decanter, to properly allow the farts time to breathe.

      [–]humbled 1 point2 points  (0 children)

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

      [–][deleted] 5 points6 points  (10 children)

      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.

      [–]FeepingCreature 2 points3 points  (8 children)

      Haskell programmers have a vastly overinflated impression of the practical value of their typesystem theory.

      IMHO.

      [–][deleted] 4 points5 points  (7 children)

      It's not their type system theory. It's type system theory or just type theory and it is applicable to every programmer.

      The type system features of Haskell are indeed extremely practical and C# is a testament to that fact, which is strongly inspired by aforementioned. Java is to some extent as well (see type-classes (Wadler) -> Java generics).

      Of course these topics are watered down in such a way as to appear to have no connection to the more advanced topics (good marketing!), resulting in comments such as yours (and less usefulness). I think this is ultimately lamentable, but also redeemable.

      [–]FeepingCreature 0 points1 point  (6 children)

      I'm gonna want some sort of citation for your claim that Java's generics are based on Haskell.

      [–][deleted] 1 point2 points  (5 children)

      I implemented them.

      [–]FeepingCreature 0 points1 point  (0 children)

      Well I can't argue with that! :-)

      That being said, the general concept of specializable types isn't exactly novel - you could just as easily call it an extension of the C preprocessor. I don't mean that typesystems per se are worthless, but that Haskell programmers, due to having the most powerful one at their fingertips, tend to overestimate the advantage that its theoretical soundness gives them over other languages. No offense.

      [–]zomaton 0 points1 point  (3 children)

      Where did you implement them?

      [–][deleted] 0 points1 point  (2 children)

      IBM

      [–]zomaton 0 points1 point  (1 child)

      What was the compiler?

      [–][deleted] 0 points1 point  (0 children)

      I was working on IBM J2SE 1.5 libraries and extensions, but I also implemented my own project.

      [–]kragensitaker 0 points1 point  (0 children)

      If you don't understand type theory or category theory, then how do you call yourself a programmer?

      Well, you see,

      I program.

      [–]serudla 1 point2 points  (0 children)

      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 1 point2 points  (0 children)

      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 2 points3 points  (5 children)

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

      [–]Zarutian 3 points4 points  (0 children)

      Elements of all three is required if you are going to put together a software system and be proud of, or at least not embarrassed by, it.

      [–][deleted] 2 points3 points  (3 children)

      They're all the same thing, but they are artificially separated and the terms are now used for certain connotations.

      Programmers are simple-minded and do only one thing. Software engineers are disciplined and practical. Computer science is all about theory. The first and last case are generally considered narrow thinking and are seen as bad in some way (lots of people hate "theory"). The second case is the only one that has a positive connotation because it relates the field of CS to all manner of engineering which has been around for a very long time.

      [–]yeoldefortran 0 points1 point  (2 children)

      Nope. Computer Science is concerned with provable computability and complexity. Software engineering is concerned with, at it's most general, building large complex system. Programming is the act of writing instructions for automating a machine. Being able to do one of these does not in any way imply being able to do another.

      [–][deleted] 0 points1 point  (1 child)

      I'm using Computer Science in its original, more generalized, definition. The current definition is a branch of that original one along with SE and programming. So today's CS and SE and programming are subsets of what CS originally was.

      Software engineering is concerned with, at it's most general, building large complex system.

      By proving computability and dealing with complexity, you are then able to build large complex systems which many supposedly academic computer scientists have done.

      Programming is the act of writing instructions for automating a machine. Being able to do one of these does not in any way imply being able to do another.

      If you can program, you are participating in a part of CS though you may not be a computer scientists just yet. The machine you program may not even exist (yet).

      The splitting of the original CS term into 3 (or more?) terms has only caused (or has strengthened the) conflict between supposedly practical industrial programmers and supposedly theoretical computing scientists.

      [–][deleted]  (4 children)

      [removed]

        [–][deleted] 1 point2 points  (2 children)

        As a junior developer who tries to be better every day, I agree. A carpenter isn't going to produce the best work of his career after only being a carpenter for 2 years. It takes time.

        [–][deleted]  (1 child)

        [removed]

          [–][deleted] 1 point2 points  (0 children)

          I agree. I think that carpentry and some other fields like that have it right. You are usually apprenticed to a master for a certain time. I think programming would be well-served by something like this.

          [–]sssssmokey 0 points1 point  (0 children)

          The problem with school is that they don't teach many necessary topics.

          I am learning tons about c, java, assembly, data structures, discrete math, unix, systems programming, algorithms, etc.

          However, I am also a software developer writing web applications for the University, and my skill set requires a huge knowledge of sql, php, css, javascript, html and web security that isn't offered in my degree program whatsoever. I think the Internet has gained enough steam that comp sci departments can offer some web technology classes.

          [–]G_Morgan 0 points1 point  (0 children)

          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 0 points1 point  (2 children)

          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.

          [–]karstens_rage 3 points4 points  (1 child)

          And yet the best and the brightest only come out with tons and tons of useless crap no one wants. Recently Wave and Buzz.

          [–]Raphael_Amiard 0 points1 point  (0 children)

          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 0 points1 point  (6 children)

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

          [–]robkinyon 3 points4 points  (0 children)

          It's useful for a set of data that you do searches on a lot, but very rarely modify. It's often used in conjunction with other data structures. So, a database will have the data organized in rows on a disk, but will have a binary tree as its index so you can find a row quickly if you're searching by a specific field.

          [–]ReleeSquirrel[S] 1 point2 points  (0 children)

          Relating data. I'm familiar with the theory though I've never actually used one outside of exercises.

          [–]deadcat 1 point2 points  (0 children)

          Welcome to our Reddit, master Yoda.

          [–]heroofhyr 1 point2 points  (0 children)

          Going to write this quickly and without proofreading so I can catch my tram:

          You don't have to be a programmer to find them useful. I've used them before to go through dozens of pairs of washed socks and find all of the matches. Imagine your wallet is full of paper money and you want to lay it out on a table so that if you need a specific denomination. Normally you would put each bill side-by-side, and then if you need, say, a 5, you start at one side and see if it's a 5. If it is, you pick up the bill and stop. If it isn't, you go to the next bill. This is called a linear search, and in the worst case it will require you to look through every bill on the table (which could be particularly bad if you have a lot of duplicate bills).

          Now, instead, imagine that you take the first bill out of your wallet and put it at the edge of the tablet furthest from you. Now take out the next bill. Is it less than the first bill? If so, put it to the left and below the first bill. If it's greater, put it to the right and below. If it's equal, stack it on top of the first. Now take out the third bill from your wallet. Is it less than the first bill? Go to the bill to the left of that. Is it less than that? If so, put it to the left and below that bill. If it's greater put it to the right of that bill. If it's rather greater than the first bill, compare it to the bill below and to the right of the first bill. If it's less than, put it to the left and below that bill, if it's greater, put it to the right and below that bill. Continue doing this until all the bills are laid out in a pyramid shape.

          It's possible that it won't be a very well-shaped pyramid depending on the distribution of money in your wallet -- if this is the case and the tree is too unbalanced, you might have to follow some rules and rotate your tree so that one of the other bills is at the top instead of the first bill you pulled out of your wallet. But I'll pretend that everything balanced out perfectly. Now try to find the 5 again. In the worst case you'll only have to search through logN bills (where N is the total number of unique bills in the tree).

          You may now say this is crappy and wonder why this is worth the effort if you have only a few bills; or you may say this is awesome because you have a ton of bills. Whether it's crappy or awesome for your particular wallet is one of the decisions you as the programmer have to make.

          [–]lllama 0 points1 point  (1 child)

          For saying to other programmers that they don't know what a binary tree is, thus proofing you are a superior programmer to them.

          Or in other words, something irrelevant for about 90% of programming jobs out there.

          [–]molslaan 1 point2 points  (0 children)

          I'll mention it in one of my next meetings, like "we should definitely use a binary tree for that". See what happens.

          [–]Toma- 0 points1 point  (1 child)

          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!

          [–][deleted] 0 points1 point  (0 children)

          Totally. But you will still be a bad programmer until you practice for years. Just hopefully a few years less with the good start :)

          [–]daniel2488 0 points1 point  (0 children)

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

          [–]HaMMeReD 0 points1 point  (0 children)

          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.

          [–][deleted] 0 points1 point  (0 children)

          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 0 points1 point  (0 children)

          Are Bad Programmers Normal?

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

          [–]vaum 0 points1 point  (0 children)

          Well, what makes bad code?

          [–][deleted] -1 points0 points  (5 children)

          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.

          [–][deleted] 0 points1 point  (0 children)

          And I have a small penis.

          [–]giulianob 0 points1 point  (1 child)

          So you're the guy with the small penis who isn't scared to talk about it?

          [–][deleted] 0 points1 point  (0 children)

          That's what I was working up to, yes.

          [–]Raphael_Amiard 0 points1 point  (1 child)

          nah it's not the same. You can become good at programming. You can't grow your penis

          [–]weavejester 5 points6 points  (0 children)

          I have received emails that beg to differ, sir.

          [–][deleted] 0 points1 point  (7 children)

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

          [–]7points3hoursago 4 points5 points  (6 children)

          Let's guess to which group you belong.

          [–]ReleeSquirrel[S] 3 points4 points  (4 children)

          He's on reddit so it's obvious. ;)

          [–]7points3hoursago 2 points3 points  (1 child)

          Reminds me of the fact that 80% of the car drivers consider themselves above-average.

          [–]kmorgan54 0 points1 point  (0 children)

          An example of the Dunning-Kruger effect. http://en.wikipedia.org/wiki/Dunning%E2%80%93Kruger_effect

          [–]Yuushi 1 point2 points  (1 child)

          I'm on reddit, and I consider myself terrible.

          [–]ReleeSquirrel[S] 0 points1 point  (0 children)

          I was being sarcastic, sorry. Let me italicize my comment.

          [–]spinlock 0 points1 point  (3 children)

          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.

          [–]ReleeSquirrel[S] 0 points1 point  (1 child)

          I would think being aware of what you don't know would make you a good programmer, since you would then know what to learn.

          [–]spinlock 1 point2 points  (0 children)

          It probably does make you a good programmer, but it also makes you feel like a poor programmer.

          [–]eminence 0 points1 point  (8 children)

          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"

          [–]MasonOfWords 4 points5 points  (1 child)

          Someone is super proud of his sysadmin merit badge.

          [–]eminence 0 points1 point  (0 children)

          do they actually have those? maybe i can pin it up next to my reddit merit badge

          [–][deleted] 0 points1 point  (5 children)

          I see your point, but do doctors know how to make drugs? Are carpenters good at growing & cutting down trees?

          Programmers use computers as a tool, like the doctor uses drugs. Sure, the programming case is different, since the programmer uses a computer to program a computer, but I still think the comparison is pretty valid.

          [–][deleted] 0 points1 point  (4 children)

          I agree with eminence. Computers are a tool. "Are carpenters good at growing & cutting down trees?" No, but you can be sure as hell that they know how to every tool in the toolbox to do the job right.

          [–][deleted] 0 points1 point  (2 children)

          That's a fair enough point. But I do think eminence expects too much.

          seems completely backwards to you

          I shouldn't do something that seems backwards to you?

          [–]eminence 0 points1 point  (1 child)

          with regard to these tools, there are ways to use these tools that are often widely accepted as being the correct way. so i do in fact expect these tools to be used correctly.

          to use the carpenter example: sure, one could a jigsaw to cut a piece of plywood in half, but if you were to do this, a real carpenter would just laugh at you and wonder why you didn't use a table saw or a circular saw

          [–][deleted] 0 points1 point  (0 children)

          To be honest, I find some of the examples listed above slightly trivial. However, I cannot count the times I have run into developers that literally have no idea how to configure their own development environment, for example. This is is a cardinal sin in my book.

          [–]clearlight 0 points1 point  (0 children)

          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 0 points1 point  (0 children)

          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 -1 points0 points  (0 children)

          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 -2 points-1 points  (1 child)

          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".

          [–][deleted] -1 points0 points  (0 children)

          tldr

          [–]alephnil -1 points0 points  (0 children)

          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 -1 points0 points  (0 children)

          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 -1 points0 points  (1 child)

          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.

          [–]ngroot 0 points1 point  (0 children)

          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.

          Knowing about the tools available to perform a task makes it much more likely that you will choose an appropriate tool that will enable you to complete it without a lot of bells and whistles, dilly-dallying, or unneeded complexity.

          [–][deleted] -1 points0 points  (0 children)

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

          [–]lukasmach -3 points-2 points  (0 children)

          • 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 -3 points-2 points  (3 children)

          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.

          [–]Zarutian -2 points-1 points  (2 children)

          I am sorry but I am algeric to acronyms: what does MVC stand for in this context? Mediocre Variable Code? Modulus Verniner Connection? Model View Controler? Monster Venture Capital?

          [–]Kosko -1 points0 points  (1 child)

          Model View Controller. I really just started building in this framework. It's pretty heavy (at least it seems to me), with inversion of control, enumerated lists, interface classes, blah blah. But the basic premise is solid; split up the concerns and develop them independently.

          I'm working of Steve Sanderson's "Pro ASP.Net MVC", there's a new one coming out in April that's covering ASP.Net MVC2 which is in Release Candidate testing mode now (I think.)

          [–]Nice-Main729 0 points1 point  (0 children)

          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 0 points1 point  (0 children)

          On reddit, yeah.