Please create an account to participate in the Slashdot moderation system


Forgot your password?
Programming Businesses Education Software Technology

Real World Code Sucks 292

An anonymous reader tips an article at El Reg about the disparity between the code you learn at school and the code you see at work. Quoting: "There is a kind of cognitive dissonance in most people who've moved from the academic study of computer science to a job as a real-world software developer. The conflict lies in the fact that, whereas nearly every sample program in every textbook is a perfect and well-thought-out specimen, virtually no software out in the wild is, and this is rarely acknowledged. To be precise: a tremendous amount of source code written for real applications is not merely less perfect than the simple examples seen in school — it's outright terrible by any number of measures."
This discussion has been archived. No new comments can be posted.

Real World Code Sucks

Comments Filter:
  • by Polo ( 30659 ) * on Friday December 21, 2012 @06:18PM (#42364769) Homepage

    It might be interesting to read The Rise of "Worse is Better" []

    • by firewrought ( 36952 ) on Friday December 21, 2012 @06:53PM (#42365133)

      It might be interesting to read The Rise of "Worse is Better" []

      That's a great article for high-brow programmers who want to triple-plus-abstract and design-pattern everything. You know... the folks who Joel Spolsky calls "architects astronauts". However, notice that this article is readable and thoughtfully characterizes the two coding styles it trying to differentiate. Fundamentally, this person knows their craft.

      This is unlike some of my coworkers, who still embedd SQL straight into their GUI's. (I know of one of our apps where all the methods have the same 30+ parameters being slopped around [to represent a row from table X] because the original dev team couldn't be bothered to create a class called "X" to represent the concept of X and so pass around 1 reference.)

      These people aren't heroic real-world veterans who sagely ignore the pretentious chatterings of academics... they're simply folks who don't understand how to express themselves clearly in code, much less the runtime environment, compilation process, or other fundamentals of the basic tools they've worked with for the past ~5 years.

    • by PRMan ( 959735 )
      It might be, if it weren't black on gray with no contrast. But since it is, I'll never know.
  • Captain Obvious? (Score:5, Insightful)

    by Anonymous Coward on Friday December 21, 2012 @06:20PM (#42364791)

    This just in: real world a lot harder than school.

    Gee, thanks Slashdot!

    • by K. S. Kyosuke ( 729550 ) on Friday December 21, 2012 @06:37PM (#42364971)
      The first thought that occurred to me is the equivalent situation in literature: People go to school, read and learn from Shakespeare, Austen, Melville, Twain, Hemingway, Faulkner, Tolkien...and then they go out and write Twilight and Hunger Games. I guess some people simply aren't cut for it?
    • This just in: real world a lot harder than school.

      Gee, thanks Slashdot!

      The reason is pretty obvious. The 25-line program you write for a school assignment is not the same as the 5000 lines you are writing to implement a set of vague business requirements.

      • by ShanghaiBill ( 739463 ) * on Friday December 21, 2012 @07:12PM (#42365323)

        The 25-line program you write for a school assignment is not the same as the 5000 lines you are writing to implement a set of vague business requirements.

        Some of those 25-line programs are not so good either. If you really think students write good code, get a job as a TA and grade some assignments.

        • Re:Captain Obvious? (Score:4, Interesting)

          by Macman408 ( 1308925 ) on Friday December 21, 2012 @07:36PM (#42365521)

          This, and even the *book* is wrong half the time. Given the pressure to come out with a "new edition" every couple of years that many publishers and authors face, they re-write many parts of the books, including examples and problems. Often, it's clear that what the author wrote hasn't even been compiled before, as there are glaring syntax errors. (Obviously, some books are better at this than others.)

          Most of the people I work with produce much better-looking code than a college student. Interns come in periodically and help prove that point; they write for ease of coding, not ease of reading or maintenance or reuse or anything nice like that. The code from more experienced people is by no means perfect, but they've at least seen both good examples and bad examples when they have to touch somebody else's code, and they tend to pick up a few of the good habits while dropping a few of the bad ones.

      • by Phrogman ( 80473 ) on Friday December 21, 2012 @07:14PM (#42365355) Homepage

        Then in school they should be recreating the actual real world experience, you know:
        * a representative from the "Business" comes to you with a vague concept of what they want, mostly consisting of "Something like X" but more like "Y" with some of the features of "Z" (3 completely different things that have no apparent relationship to each other). After a few days of meetings you determine that what the person wants is based more on the colors used and the layout being pretty to them and not at all on the features or functionality.
        * You then seek out a group of various people who actually know what might be required, and grill them to try to get an idea of the features and functionality required. From this you create an initial design document.
        * You run the design document that describes what you think are the features and functionality past the people above who all agree you are on the right track. You add more details and they all agree its perfect. Mostly they don't actually understand what you are talking about but they nod their heads sagely and agree because they don't want to look incompetent.
        * You begin coding (or possibly get together with a team and fight over things for a few days/weeks/months) and get a prototype built. You show it to those you have spoken with and again its on the right track.
        * You code up the first version. You reveal it to people and its "great".
        * Then the people start filtering in with design "suggestions" that mean massive changes to what has been written and done, possibly shifting the entire project in a different direction. These conflict with each other and trying to find the middle ground occupies as much of your time as actually trying to write anything.
        * The marketing people come into the picture and it turns out that *they* are the ones that really have the authority to make the design decisions, not the people who you originally talked to, but as an added bonus the marketing people don't have the slightest clue about the required features or functionality - just what they think they can sell to customers. Getting their salable features shoe-horned into the program becomes your top priority now.
        * The program also has to look "pretty" so the art department enters the picture and they demand massive changes so that the layout is much nicer and easier for them to do, minimizing their workload as much as possible because they are completely overworked and under-budgeted. You meet with artists in rooms that are completely dark and stare at photoshop images that are renderings of what they see the program looking like. It bears no resemblance to what you have been working on and they have made massive changes to everything renaming all the menu entries etc. It is however pretty, or rather the 3 different versions of it are pretty, and you have to wait until marketing determines which one is the best.
        * now you are way off schedule because of all the monkeys who are making changes based on whats the most important thing from their perspective.
        * Eventually its all nailed down and you hurriedly code the new first version up as fast as possible because of pressure from above to be "done this thing already".
        * At the last moment when its done, it gets cancelled to be replaced by some other project which is higher priority, or they announce it must be entirely recoded in a different language/script.

        Shove that student into this environment. Get people to play the various roles that are about as knowledgeable as people you will encounter in the corporate environment - which is to say find the most qualified idiots you can and put them in the roles.


        • My questions are not tainted by real world experiences, so feel free to enlighten me. 1. If it is the marketing people who have the final say, why aren't they part of the process from the beginning? 2. If design people can throw in fundamental changes to UI, why are they the last to be asked? In sum: Is this just mismanagement or is there some fundamental truth about real world development that escapes me somehow?
          • Because an incredible percentage of products get canceled and the marketing people have learned not to waste their time on some shiny new idea that's probably going to get canceled anyway. Wait a few months and see if the project survives and it's worth investing your time, because if you touch/interact with a project and it's canceled, that of course makes you look bad and has wasted your time. There's the additional benefit that, if the developers are late, that gives you a scapegoat if your marketing cam

          • That's not the way businesses operate, and the larger they are the more layers of BS things filter through. The person who champions the project hands it off to a subordinate, who hands it off again, etc. By the time it gets to the poor sap who had to bid out the project you're lucky if you get a cocktail napkin sketch of a UI concept and a few vague notes about what it should do.

            There is another form of this that I deal with quite often, where upper management concieves of something that is totally impra

        • Honestly, this should be the final project of any decent software development course.

        • Re:Captain Obvious? (Score:5, Interesting)

          by jimshatt ( 1002452 ) on Friday December 21, 2012 @08:34PM (#42365985)
          Reminded me of a comic by the oatmeal: []
        • Even your longer example doesn't do enough justice to how much of this problem is management based. This article was terribly biased toward blaming programmers for these issues. Schedule pressure to release on a date no matter what causes more bugs than anything else. Having some sort of deadline is necessary; if left on their own, programmers like to tinker with stuff forever. But you can only compress things so much, and management requirements are often impossible to hit. The standard example here i

        • Of god that is so true it is not even funny. :-)

          "Politics" (and ego) is the number one reason "Real World" software sucks so much.

          "If engineers built buildings the way programmers write code then the first time a woodpecker came along it would destroy civilization."
          -- Murphy's Computers Laws (Murphy was an optimist!)


        • by UnknownSoldier ( 67820 ) on Friday December 21, 2012 @09:11PM (#42366235)

          * Meskimen's Law: There's never time to do it right, but always time to do it over.

          * Ninety-Ninety Rule of Project Schedules: The first ninety percent of the task takes ninety percent of the time, and the last ten percent takes the other ninety percent.


      • say nothing of the fact that instead of writing a program from scratch, you're forced to maintain others' programs instead, or to add what you write to existing (fundamentally crap, poorly-maintained) code.


        • by Phrogman ( 80473 )

          I recall reading about someone being brought in to replace the (sole) developer for a key piece of business software because the previous one had been fired. (Caveat: I have no idea if this is true and can't recall where I encountered it).

          They opened up the source code to give it a check and discovered that the previous developer had used variable names that varied mostly in the number of letters used. So you had variables named like:
          $m, $mm, $mmm, $mmmm, $mmmmm, $mmmmmm,
          $sa, $saa, $saaa, $saaaa

          and so on. N

    • Not at all, most of the real world problems are problems you see solved in academia, very well. The code quality is a direct result of the "coding to the business need" principle, where everything is done based on a business identified function/schedule.

      The persistent problem with purely competitive environments is that there will always be an incentive to beat the other guy, at any cost.

      • Not at all, most of the real world problems are problems you see solved in academia, very well. The code quality is a direct result of the "coding to the business need" principle, where everything is done based on a business identified function/schedule.

        Perhaps more precisely, that the code produced in the "real world" is often "graded", in the immediate term, by a PHB that will be satisfied if it superficially appears to work (they'll eventually get upset at the costs produced by less-obvious defects a

    • This just in: real world a lot harder than school.

      Gee, thanks Slashdot!

      PHB: Nonsense! Programming is dead easy. My 10-year-old nephew wrote a program just the other day. It makes a little square box bounce around on the screen. We don't need these overpriced prima-donnas spouting techno-babble about Separations of Concerns or stuff like that. A half-hour and you can have web pages on the screen and ready for production tomorrow. All You Have To Do Is...

  • by doubleplusungodly ( 1929514 ) on Friday December 21, 2012 @06:20PM (#42364799)
  • same... (Score:3, Insightful)

    by jimpop ( 27817 ) * on Friday December 21, 2012 @06:22PM (#42364823) Homepage Journal

    It's no different than business school examples vs real world practice.

    • Re:same... (Score:4, Funny)

      by Anonymous Coward on Friday December 21, 2012 @06:29PM (#42364893)

      It's no different than business school examples vs real world practice.

      And English class samples (such as books and essays that they have you read) versus the comments you read on YouTube.

  • by Jane Q. Public ( 1010737 ) on Friday December 21, 2012 @06:24PM (#42364845)
    Author of TFA had some bad experiences, worked for some bad software houses, generalizes it to "everybody".

    I do not agree that his generalization is necessarily valid. Sure, code in the real world seldom looks like code in textbooks, because code in textbooks is usually designed to solve a discrete problem in a stand-alone way. In the real world, this code will be part of a larger system under circumstances that are less ideal. (Different business requirements, or slightly different mode of operation, etc.)
    • by Chirs ( 87576 ) on Friday December 21, 2012 @06:40PM (#42364997)

      I work in enterprise embedded stuff where the systems are five nines reliable, and even there we've got problems. We recently ran into a day-one bug that suddenly turned and bit us because we switched to a different brand of hard drive.

    • I'd say in most cases he's right. I've worked in places with people of all varieties of skill levels and education and there is one consistent thing and that is code quality gets compromised. If you're lucky it's just a few bodge jobs, if not, then you have a whole heap of shit that has no value.
  • by vanyel ( 28049 ) * on Friday December 21, 2012 @06:25PM (#42364857) Journal

    It's "rarely acknowledged" because it's just a given...

  • School code (Score:5, Insightful)

    by phantomfive ( 622387 ) on Friday December 21, 2012 @06:27PM (#42364879) Journal
    The opposite is true too: code you see in textbooks is often horrible. It omits error checking, often uses global variables, makes assumptions, etc. Someone mentioned that K&R has memory leaks all over the place, because it's more readable.

    The goal of textbook code is to be readable, to communicate, not to handle every possible case. This means industry code is often less readable, but more solid. I'm sure I've missed other ways academic code is bad.

    Of course a lot of industry code is unreadable and also not solid. That's another issue.
    • Re:School code (Score:5, Insightful)

      by GGardner ( 97375 ) on Friday December 21, 2012 @06:58PM (#42365191)

      I'm sure I've missed other ways academic code is bad.

      The biggest difference is that academic code is _short_. If your whole code base is 10k lines, it's easy to cover all the requirements in a clean design. If you are dealing with millions of lines, there's all kinds of oddball unforeseen interactions and requirements that pop up way late in the game.

      • Re:School code (Score:4, Insightful)

        by SydShamino ( 547793 ) on Friday December 21, 2012 @07:16PM (#42365369)

        This is what I came here to say. (Disclaimer: I'm a hardware engineer and most of the code I write is in HDL.)

        There are two factors at work.
        1. With the exception of big thesis-style projects, most academic work is scoped for you by the nature of the assignment or the teacher. This is almost never true in the real world.
        2. When options are available, the proper way to write code is the way that is most readable and supportable. However, the most readable way to write a given piece of code varies by its scope.

        Thus, as you work on real-world code, you might design something a certain way because it's the cleanest, most readable way you know. Then, later, as the scope of the project is made more clear, either through your own investigation or through changing business requirements, you have to modify the code, but you don't have enough time to toss it all out and start over with a new design that is the most cleanest, readable way to do things given the new requirements. This is most especially true when the scope changes in little steps, each one of which seems small enough to not be a big deal.

        My example is with state machine design. For a simple system that moves between a few states and has a few Moore outputs, a single-process state machine with good state names and a few comments is readable and supportable - it all fits on one page. But if I'm designing a 50-process state machine to handle a big, complex process (and can't break it down into multiple machines for timing or whatever reasons), then I'll use a multi-process state machine, with state and nextstate separated, and probably a dedicated process for each I/O or group of I/O signals, where each one can get it's own page-sized bit of code and comments. The latter style is much harder to read and follow for simple systems, but if the former type morphs into the latter type, I need to cut it out and start over. That's only possible when time permits, and I don't own my time when I'm on the job.

        And all of this assumes that you even bothered to write the code the most readable and supportable way the first time. Far too often the first time code is written, it's written to get "something out there working" so the analog guys or marketing can test their stuff or show it off. And then you don't get time to even fix that code into something readable in the first place. With a project manager and a few software and analog engineers waiting on you, demanding time to do things right the first time can be challenging.

    • by arielCo ( 995647 )

      Textbook code is meant to illustrate only the thing being discussed. A book would be less readable if every snippet contained the proper boilerplate for exception handling, pre-execution checks, malloc+free tracking, etc... That's usually covered in separate sections, and the professional coder should be aware of the need even if K&R didn't lecture him on it.

  • No surprises here. (Score:5, Insightful)

    by csumpi ( 2258986 ) on Friday December 21, 2012 @06:28PM (#42364885)
    Because in real life:

    - specs change constantly
    - need to work with crap that's already there
    - there are deadlines
    - need to get stuff done

    And I'm pretty sure I'm forgetting some other points.
    • by Xtifr ( 1323 ) on Friday December 21, 2012 @06:51PM (#42365107) Homepage

      - Requirements are messy (even not counting the fact that they change constantly)
      - Textbook code is designed to look clean, but often ignores important edge cases for the sake of simplicity. (See previous point.)
      - Cleaning up the code may potentially introduce bugs, so once the code gets past QA, it's often considered untouchable until a demonstrable problem is found.

      I'm sure there's even more...

      (Test-Driven Development (TDD) is supposed to help address that last point, but A) it's not always perfect, and B) it's not universally used.)

      • In my company too, refactoring is considered taboo. (hey, that rimes!) Code gets copypasted all over the place because nobody dares touch a piece of working code. So when a bug is found in the duplicated code, it's fixed in 7 out of 10 (all slightly different) duplications (or worse, just the one place the bug shows up).
        I rather take the blame when a new bug is introduced by refactoring a piece of code so it can be used from multiple sites, than create another duplication. I then usually mumble something a
    • by jnaujok ( 804613 ) on Friday December 21, 2012 @06:51PM (#42365109) Homepage Journal
      You forgot:

      - No one is willing to fix code that already exists because it works "good enough"
      - No one is willing to expend the resources (read time and money) to go back and rewrite bad piece of code.
      - Fear of new code exposing how bad the other code is.

      (32 years of real world coding.)
      • Ah yes! And what I also really hate, is people not telling each other that their code isn't good. I mean, everybody makes mistakes, but for the love of code, let's prevent the same mistakes from happening over and over again.
    • by gutnor ( 872759 )

      Another one: in real world you get stuff wrong.

      • * Because you are just human and if you code 8 hours a day, 250 days a year, a few of your numerous mistakes will made it through to the client.
      • * Then you get stuff wrong because you are not alone, and communication between humans is hard, so hard that it is another profession altogether. Something will eventually be lost in translation situation between you, your team, your bosses, your client.
      • * More importantly, unlike in the books, most of the choices yo
  • School v. Reality (Score:5, Insightful)

    by girlintraining ( 1395911 ) on Friday December 21, 2012 @06:28PM (#42364887)

    This just in: Examples provided in school have no practical real world application. Duh. In the real world you have things like deadlines, bosses, and clueless managers. When you screw up in class, the teacher tells you where you messed up and you get a chance to do it again. In the real world, when you screw up you probably won't know what you did, at least not right away. And you're going to have to figure it out while everyone is mad at you, calling your phone, and asking why it died.

    I don't know where this idea of the Zen Programmer(tm) comes from with visions of calm blue waters and bright bleached sand and everything is calm, thought out, and composed. Programmers I know hammer down mountain dew like it's nobody's business. They do not spend months debugging and thinking about it academically: If it works, you move on to the next thing. Don't bitch about the quality of the code (manager or academic) in the real world because there are almost no programmers in the corporate world that sit around thinking in O notation and figuring out the best and worst case scenario for every line of code. They bang out 500 lines in a few hours and then hit compile and hope to god it works on the first go.

    That's reality people -- you don't have the time, the resources, and if you took the academic attitude to work with you, you'd be cut up and used as shark food by everyone else for being so damn slow and pragmatic when they need things working tonight so they can go home after being there for 15 effing hours to make the latest milestone.

    • by neminem ( 561346 )

      Really? Generally speaking, when I was in school, when I turned in a homework assignment, I was told where I messed up, and then went on to the next assignment. Only rather rarely was I given even one assignment to fix any of my previous mistakes, as far as coding went, and the only time there was any kind of "keep fixing it until it's fixed" mentality to any school-related project was my whole-year-long senior project... which was part of a program designed to give us real-world experience by giving us act

      • Homework assignments are different from real-world code. Homework assignments are rarely built on code written by other people. Homework assignments are rarely checked for robustness against bad inputs; students usually know exactly what sort of input to expect and need not worry about anything else. Homework is usually small -- rarely do you see homework assignments exceed 1000 program statements in any language.

        Real world code is not like the code students are assigned in school.
      • when I was in school, when I turned in a homework assignment, I was told where I messed up, and then went on to the next assignment.

        Me too. They changed that though when the parents complained that their precious snowflake wasn't getting first place in everything; So they abolished competitions. Now there's no such thing as an 'F' in many schools, and they have about half a dozen more letters to represent just how exactly their kid didn't 'F'ail. It is (as my teenage sis would say) "ridonkulus".

        Yes, sometimes due to deadlines (or simple cost-benefit analysis), not everything will always be perfect when it ships, but I'd certainly always take code written by a company and designed to be shipped, over code designed to be written and turned in as a homework assignment...

        So would I: Because there's a use for one, rarely for the other. Articles like this are like saying "We shouldn't use cars because they pollute"

    • by SirLurksAlot ( 1169039 ) on Friday December 21, 2012 @06:52PM (#42365131)

      Don't bitch about the quality of the code (manager or academic) in the real world because there are almost no programmers in the corporate world that sit around thinking in O notation and figuring out the best and worst case scenario for every line of code. They bang out 500 lines in a few hours and then hit compile and hope to god it works on the first go.

      That's reality people -- you don't have the time, the resources, and if you took the academic attitude to work with you, you'd be cut up and used as shark food by everyone else for being so damn slow and pragmatic when they need things working tonight so they can go home after being there for 15 effing hours to make the latest milestone.

      You're working with the wrong programmers then. See, you want the ones that write quality code and test-drive the crap out of everything so they don't have to put in 15 hour days to make the latest milestone. By the way if you're working 15 hour days it means you're mismanaging your manager and their expectations (and/or you suck at your job).

      • by jareth-0205 ( 525594 ) on Friday December 21, 2012 @09:18PM (#42366283) Homepage

        You're working with the wrong programmers then.

        Yes, because it's always possible to work with the best programmers the world can provide. In the *real* world there is a finite availability of top programmers, and they might not be working where you are.

        You show yourself to be very naive if you think that every business has the time to let you do TDD, and will provide you with a perfect, experienced team of developers.

    • there are almost no programmers in the corporate world that sit around thinking in O notation and figuring out the best and worst case scenario for every line of code.

      Wow, speak for yourself. I DO think of this on every line of code I write.

      Of course, the vast majority of code is either O(n), O(n^2), or O(1), so usually this isn't actually hard, unless you put vectors in your stacks or something.

      The question is, why aren't you thinking about how long your code will take to execute?

    • by cas2000 ( 148703 )

      so what you're saying is that programmers need to stop being such fucking wusses that they put up with shit working conditions like 15 hour work days?

      or maybe they should form a union.

    • by mikael ( 484 )

      Hardware and software was a lot simpler back 30 years or more. One of our courseworks was to write keyboard and network card device drivers along with a text editor and simple chat programs. A keyboard driver could be written using BIOS interrupts in page of code. Same with a network card driver and text editor/chat program. Even source code control was done using SCCS which meant that only one file could be checked out at a time by one person.

      Applications programming was straightforward - create a main win

  • Wow, check out this quote from the article:

    in casual discussion, developers and tech managers will talk about all the wonderful things their system does, the stellar technical skills of their team, and how much their users love them — and all that may be true.

    Do developers and tech managers really go around talking about how much their users love them? Why have I never met any of these developers and tech managers?

    • by Samantha Wright ( 1324923 ) on Friday December 21, 2012 @06:35PM (#42364957) Homepage Journal

      The last page bashes Haskell using a snippet from Uncyclopedia as anecdotal evidence that it is "all but impossible to write readable code" in Haskell.

      Beyond it is another dimension: a dimension of whinge, a dimension of fallacy, a dimension of diminished journalistic integrity. You're moving into a land of more shadow than substance, of vague and half-baked wit; you've just crossed over into the Register.

  • To be precise: a tremendous amount of source code written for real applications is not merely less perfect than the simple examples seen in school — it's outright terrible by any number of measures.

    Life is messy and the real world is complex; deal with it.

  • In Other News... (Score:5, Insightful)

    by SirLurksAlot ( 1169039 ) on Friday December 21, 2012 @06:38PM (#42364981)

    Water is wet, the sky is (perceived as) blue, the world *did not* end, etc.

    On a more serious note I wouldn't describe any of the code examples I encountered in school as perfect or "well-thought-out" specimens." Nearly every one of them was a trivial case which ignored most error cases and expected the client human/system/software to be well-behaved. I've often thought that Comp. Sci. students (3rd or 4th year) should be forced to pick up someone else's code and refactor it into something workable. I'm not talking about the disgustingly huge and unmaintainable messes that we work with out in the real world, but something big enough to give them an inkling of the kind of scope they'll be expected to deal with.

    I also think that if you're not learning TDD in school these days you're not getting your money's worth, and you'd actually be jeopardizing your career by not learning this early, as it is a life-saver out in the real world.

  • by PolygamousRanchKid ( 1290638 ) on Friday December 21, 2012 @06:38PM (#42364983)

    In the academic world, if you were tasked with picking a perfect team, you would steal players from Real Madrid, FC Barcelona, a fistful of Germans, Franck Ribery, etc.

    In the real world, if you are tasked with managing a programming project, you don't get to pick the best. You are given some young kids with more energy than sense, an old, wise, but disgruntled experienced guy, who nobody listens to, a few folks who really don't give a damn, and most of them really truly detest each other. So you try to make out as well as you can, with what you've got.

    Hey, Mercedes are great cars, why isn't every car built like them? Well, not everyone can afford a Mercedes, and maybe most folks can get by with just a Ford.

    It's just the reality of life vs. theoretical academics. Despite the physics problems you solved in college, there are no frictionless surfaces. Or the ones that are available, you just can't afford.

  • by codepunk ( 167897 ) on Friday December 21, 2012 @06:41PM (#42365011)

    Most of the time the person claiming the code is crap is the one I find to be most to blame.

  • other way around? (Score:2, Interesting)

    by Anonymous Coward

    I've worked in opposite land apparently... Code quality output by a team of well-vetted coders that I used to work with was high by my standards - low bug rate, decent code coverage for unit tests, generally well documented.... Then I moved to a place where the product was a postgraduate project from a dozen or so CS students. No documentation, ill thought through design, no unit tests, and unmaintainable architecture choices. Why? No real-world experience and no reason for polish, so long as a "working" pr

  • Personally, I find academic code -- that found in textbooks and other teaching materials -- to be poor specimens. These are examples that teach methods and concepts, but utterly fail to account for edge cases and real-world scenarios. Real-world code may not always be pretty, but it is a lot more comprehensive than what you will find in textbooks.

    The author of the TFA is, IMHO, misguided.

    • Personally, I find academic code -- that found in textbooks and other teaching materials -- to be poor specimens. These are examples that teach methods and concepts, but utterly fail to account for edge cases and real-world scenarios. Real-world code may not always be pretty, but it is a lot more comprehensive than what you will find in textbooks.

      IME, the exact opposite is true; code in textbooks is far more often to address a specifically defined problem domain correctly (often, a problem defined in such a

  • and in IT / admin jobs CS is way off base to the point where a tech school is like a real workplace (IT setup wise) and in a tech school you learn very hands on VS the theory of it all.

  • Yeah, they're right about the state of things, but they get the "why" part totally fucking wrong:

    The most common reason for the existence of bad software is bad programmers.

    NOPE! Bad software is a result of BAD Code, even good programmers can write bad code...

    At the other end of the spectrum, many projects are sabotaged by developers who are “too good”

    NOPE! Maybe those scare quotes are there for a reason, but "doing things the most complex way possible" is usually because coding is iterative and there was no way for you to know of the unforeseeable future requirements.

    And then there’s “bad” laziness, the kind that leads programmers to cut corners or do things in the quickest possible way, rather than taking the three extra hours to do them right.

    NOPE! You're assuming that the programmer WANTED to do things the quickest way possible...

    If the system is working, almost no manager will pay just to have you recode a piece of it “the right way,” without adding any new functionality. There’s always something more important that needs to be done—until that quick-and-dirty fix blows up and (because it’s urgent) gets replaced by another quick-and-dirty fix.

    BINGO! This. Everything, all of the other bullshit is due to Management. Not just not paying to have things done right (see: Fast, Good, Cheap), but also unrealistic schedules and deadlines, new features being promised by sales without consulting the programmers, etc. Deadlines exist. That's why even a good programmer hacks in a kludge ridden short cut instead of taking the time to do it the right way: There is no time to take! The most common reason for bad software isn't bad programmers, is bad management and terrible working conditions. See also: Getting what you pay for when you outsource the programming department. The outsourced workers will get it done cheaper in less time -- Cheap, FAST -- What's missing here, eh? GOOD Sadly to compete with the fast and cheap the goodness of the software must be sacrificed.

    As mentioned above, C++, despite its superficial similarities to Java, is infinitely easier than Java to write impenetrable code in. And one language I’ve been warned about, though I’ve never had the opportunity to use it, is Haskell, an offshoot of ML. According to a friend in academia who’s studied it, it’s “the Taliban version of ML,” in which it’s all but impossible to write readable code.

    Just stop talking noob.

    In the real world, tight budgets, shortsighted managers, and unreasonable expectations from non-techies almost always conspire to make developers do things too quickly.

    You mention this and yet you somehow fail to realize THIS, not Languages, not Laziness, not Ignorance, not Hubris, is what is really the root cause of all the damn evil?! Fuck you, man. You're part of the problem.

    In conclusion: Bad software is primarily a result of GREED.

    • by PRMan ( 959735 )

      You make a good point about greed, but I think it's "e. all of the above."

      I have seen developers that were so bad they couldn't write anything good if they tried. Managers typically don't know enough or don't have time to do anything about it. Besides, they are already trying to add 2 more people. If they fire that guy, they have to add 3.

      The worst failures we have at my current company (which hires very well) are problems caused by too smart developers being too clever, creating code that is unmanage

  • by Brett Buck ( 811747 ) on Friday December 21, 2012 @06:58PM (#42365185)

    The article appears to mostly be self-indulgent/elitist crap, but there is a kernel of reality in it.

          What some of my colleagues and I have done to avoid the "obscure features" problem of "expert coders" is to ban their use. A particular language we use permits many fairly obscure features that lend themselves to writing mystery code. We simply don't use them unless absolutely necessary. This is embedded spacecraft code, we only need basic relational statements, math functions, and minimal pointer use. So we don't use some of the more obscure features (doubly-defining tables, unnecessarily complex data structures, the more bizarre capabilities of pointers, etc). The code is still maintainable 30 years later, people can pick it up and read it from cold, and modify it with ease and safety.

  • by binarstu ( 720435 ) on Friday December 21, 2012 @06:59PM (#42365199)

    From TFA: "Good software, misleadingly, is usually easy to read, but it’s not easy to write."

    What is misleading about that? The same could be said for any of the formal mechanisms we've invented for expressing our thoughts and ideas to other humans. Good oratories, good lectures, good books, good journal articles, and so on, are all easy to consume, but speaking or writing well requires tremendous effort and practice.

  • I don't think i've seen school code that ever made it past 1,000-2,000 lines of code

    My last few projects were in the 100,000+ lines of code range (multiple employees)

    Regardless of school code being good or bad, it's easy to write good code when you have clear business rules for needs to get done and you only have to write something small

  • by Dave Emami ( 237460 ) on Friday December 21, 2012 @07:04PM (#42365241) Homepage

    You look at it as "the real world sucks." I look at it as "college doesn't prepare you for the real world." It doesn't prepare you, because it doesn't expose you to it at all.

    In college (at least, when I was there), the focus was entirely on showing you good code, not showing you bad code. This is like running a medical school where the doctors-in-training only see top-form athletes and never get a glimpse of sick people. Beyond lack of experience, a lot of the time the best way to understand why certain standards or principles are good is to see what happens when they're not followed, and you just don't see that in a classroom.

    At the risk of drifting into "get off my lawn!" territory, allow me to give an example I experienced.

    During my classes ("software engineering principles" or something like that), one of the things we went over was coupling, and why loose coupling was better than tight coupling. Passing parameters is better than using a global variable, which is better than reaching into another module's guts, etc. All very reasonable, and everyone agreed that it made sense. However, nobody, including myself, seemed to give it much weight. Most of us already coded that way, anyway, so it wasn't any big revelation.

    A few months later, at a job that involved maintaining and extending a decent-sized (by early 90s standards) application, I had to work with code by a guy who declared a single variable, "s", as an 80-char string, and used that all over the place. Different functions read and wrote to "s" at their whim and without regard for what other code might be doing with it. It was used in place of function parameters, in place of function results, and sometimes just as a temporary variable. Naturally, this caused all sorts of difficult-to-predict bugs. It was when dealing with this crap that a light went on in my head and I realized, "Oh! This is what the prof meant when he said tight coupling was bad!"

  • Ideally, we'd all sit in a room and model our system, identify the classes, define all the member functions, embed all the unit tests, error conditions and comments first, and then as an afterthought, fill in the code.

    The requirements of the real world, of course, make this impossible. The real world says, "get it out on time and good enough to make money."

  • The conflict lies in the fact that, whereas nearly every sample program in every textbook is a perfect and well-thought-out specimen

    The person who wrote that clearly never had a job as a programmer.

    These days, you can't even count on code from computer books compiling, let alone being exemplars of good code.

  • ... was written by the groups that used it.

    Management gave us (Engineering) a task to complete. Either do it by hand or automate it. They didn't care. Just get it done right, on time and for a reasonable budget.

    The code started to get shitty when the computing group found us writing our own tools and took the task away. The code stank, but it was blamed on poorly defined requirements (which they collected). The s/w folks didn't have any responsibility for actually performing our work and missing schedule

  • by HangingChad ( 677530 ) on Friday December 21, 2012 @07:19PM (#42365397) Homepage

    Obviously the author has never tried to untangle outsource code. If he thinks home grown code is bad, wait until he wades through a bowl of Bangalore spaghetti code. Yummy.

    Although I did make a lot of money sorting through that crap. Many companies would just assume outsource code would work when they needed it and couldn't figure out how come their wonder app, that they got done for half of what U.S. programmers would have cost, kept crashing.

    • YES! The Indian outsource shops especially are notorious for producing poor quality code that fails to meet required minimum standards for what's acceptable in most American and European companies. To any managers out there reading this, beware of outsourced development. IBM and other big tech companies get away with it because they run their own operations in India and hire the better people. This leaves only the bottom of the barrel for your next outsourced project. That bid was cheap for a reason so do
  • by davidbrit2 ( 775091 ) on Friday December 21, 2012 @07:22PM (#42365415) Homepage
    This is why I use Access a lot. Compared to the awful ERP and operational software that's out there, the little things I throw together look perfectly fine. And if I can go from concept to deployed application in an afternoon, then that's less cost to the business. We had an old RMA tracking application written in VB6, that had the database server name hard-coded. I spent a couple of hours with Access, totally rewrote it, and actually made it better. I certainly wouldn't write an entire accounting system in Access (probably), but in a world of software written with necessary business constraints and compromises in mind, do as the Romans do.
  • It's not that real world code in particular sucks. The world sucks. The code is in it. If nature provided practically unlimited general computing power really easily, code would be frickin beautiful. Computing power is woefully constrained, so code, the tools the process it, and the systems that execute it are woefully constrained. So, bad code becomes easy to write.

  • Most text books are very simple relative to real-world code, and a great many books out there are average or poor. A large percentage of the code that you find on the internet is also bad, but it's often better than what you can find in textbooks. I've been a programmer for more than 10 years. Most of the code I have been exposed to has been pretty elegantly written. Well written code is probably more common than poorly written code for software engineers in Silicon Valley, though my vantage point is rat
  • Do you cook by following a fancy french cookbook line by line? Do you drive like on DMV test? Then why do you expect anyone to code by textbook?

    Real world code is great because it works, solve a problem and puts food on the table of company's employees. If it becomes so successful that the problems are noticeable, then there is enough funding to write version 2.0. But in the beginning its more important for the product to be out of the door as soon as possible.

  • by degeneratemonkey ( 1405019 ) on Friday December 21, 2012 @10:53PM (#42366699)
    Code is bad because of deadlines, everyone seems to agree.

    Bad is relative though. If the software satisfies its business case, and ultimately doesn't have unmanageable maintenance costs associated with it, it's basically good regardless of its failure to meet standards of elegance and clarity.

    People write good real-world code all the time, and most of it is open-source. You can attribute bad industry code to greed, and that's valid, but it doesn't necessarily imply that the result is bad. Greed isn't going anywhere and greed builds some useful stuff amidst all the messes it creates.

    Even in the projects where time is not a constraint, growing complexity often leads to programmers making design compromises. These aren't necessarily as heinous as what you find in profit-driven code, but they exist because software is hard to get right when the problem being solved (i.e., the set of requirements) is almost always a moving target.

    There is always a compromise between toiling endlessly in the realm of over-engineering, or shipping a release some time in the next century.
  • by RedHackTea ( 2779623 ) on Saturday December 22, 2012 @01:20AM (#42367235)
    When I first graduated college and got a programming job, I thought the code was a bit shit too. Then I learned about deadlines and most importantly Bit Rot []. I soon realized that you need both strokers and crankers to make a successful company (I like bowling terms).

    Crankers bang out code like there is no tomorrow. When good managers find these people, they immediately put them in the department of developing new features. Competition is fierce, and a lot of times it doesn't matter about quality but about who gets there first. End of story.

    Strokers take their time with code. They are fit for the "support queue," debugging, and any specific jobs that require needlework precision. I work in this department. I fix a lot of code made by Crankers, taking in both memory-efficiency and speed-efficiency. So when a customer finally does have 10,000 loads which the Cranker didn't foresee in his/her code, I fix it, and the customer is happy. I also provide a lot of options to the user instead of forcing the user down one path. Lastly, I do jobs that require excellent quality. Do not give money-critical new features to Crankers; give them to Strokers. I actually have used a lot of the the computer sciencey things that I learned in college like Big O, various Dijkstra algorithms, etc.

    Tweeners are the in-betweens. They are good for the basic infrastructure/architecture. They write the base library fast and with decent enough quality. For example, they may write layers around the database, GUI, etc. to make life easier. If you don't have a Tweener, then use a Stroker. If you need the product out fast though, use a Cranker and then a Stroker later on to refactor, or use a Cranker and Stroker in unison.

    To make a killer software company, you need all three. And the companies that last a long time, have managers that know how and where to place these people.
  • by eWarz ( 610883 ) on Saturday December 22, 2012 @01:42AM (#42367315)
    Call me crazy, but i think we spend too much time on complex OOP based code. No I'm not making this up, I might know more languages than you, but I've also had the unfortunate opportunity of working on more shit code than most people. We need to go back to basics. When a company can hire a 3rd party team to write a 3rd party CRM cheaper than it is to modify an internal CRM there is a problem. Pay attention to this next part: When a class library becomes so complex it takes more time to maintain the library than to write new functionality, you have a problem. It should be easy to understand a code-base without spending days learning an API. code needs to be more adaptable to chancing situations. When a pharma company can spend $600,000 per year to maintain a 3rd party CRM because a first party CRM costs millions to mod, there is a problem. Just my observation though. *glares at top 20 pharma companies* thx for the awesome paycheck.
  • by CodeBuster ( 516420 ) on Saturday December 22, 2012 @01:56AM (#42367371)
    The simple truth of the matter is that most commercial code is written by overworked developers on tight schedules and with miniscule budgets. The managers crack the whip and rush things along because the people who sign the checks don't care about quality code if it means that they won't have a "first mover" advantage in the marketplace. This is particularly true in the consumer space and the phone app world. Much of that code is just pure shit. Ironically, some of the best and worst code that I've seen in the wild comes from the open source community. Is there any good commercial code out there? I'm sure that it does happen from time to time in mature products. The engine control unit in your car or perhaps the drill bit controllers on oil field equipment or maybe the hard disk controller, but in my experience crappy code is the rule and quality is the exception. Users rarely perceive quality as long as they system works, so few are willing to pay more for it in either time or money.

"The Avis WIZARD decides if you get to drive a car. Your head won't touch the pillow of a Sheraton unless their computer says it's okay." -- Arthur Miller