They're everywhere. They exist among us. I try to escape it, but I am also one of them.
They have nice offices. They have Aeron chairs. They make lots of money and they are usually quirky and fun. They're all-but-impossible to differentiate from good programmers, except that they're far more common.
They build the software that you use in your day-to-day life.
Not the software that you enjoy. The software that you hate. The bank software that asks you too many questions and the custom-built company-wide applications that never seem to work properly.
They built the firmware for your router. They built Zango. They built Windows Vista. They built thousands of little companies and products. They wrote the instructions for your portable hard-drive and they wrote that crappy point-of-sale system. They've built just about every piece of software that you've ever encountered.
They didn't build Microsoft Excel or Microsoft Word.. but they did build Clippy. They didn't build Google but they will shape a new generation of Google products.
They don't have a solid grasp of English (or they're just lazy), so they don't comment. \ They use variable names that have nothing to do with the variables, or variable names that are acronyms. $IAKsom, $PRQ. They use global variables and gotos. They make every language into the language that they learned first.
They don't understand relational databases. They use too many tables.
They code without designing, they design without coding. They stay up late finishing projects that are behind deadline. They're underappreciated and overbudget.
They don't test nearly enough. They get it working and then move on to the next task. They don't document what they've done for the next person. They use clever programming tricks to write lines of code more 'concisely'.
They code in a language because that's what everybody else is using. They only have a hammer, and every problem looks like a nail. They use Design Patterns. They create massive object heirarchies.
They own their domain so thoroughly that they assume you give a shit and are willing to learn, too.
They use Java, PHP, XSLT. Their error messages are misspelled and grammatically incorrect. They use Hungarian Notation, and they use it wrong.
They try to quantify things that can't be quantified. They overpromise and underdeliver.
They don't understand recursion or pointers. They free their own memory and they are proud of it. They don't encapsulate anything. They hard code important variables into their programs.
Their programs are so flexible that they could do anything. They have rules engines and customizations and parallel databases. \ They organize groups into projects and projects into domains.
They specialize in one technology in exclusion of all else.
They don't build software to do one thing well. They build software to do many things, terribly.
They believe that all software should only do one thing well.
They see a contradiction and they can't parse it. Everything has to be one or the other, it can't be both!
They are so used to Linux that they cannot imagine how stupid users can really be.
They don't know Linux at all.
They don't assert() things. If it's never supposed to happen, it will never happen, right?
They use Rational Rose, Oracle, massive software packages that suffer from the same defects as their own massive software packages.
They use underpowered free-as-in-beer solutions because they aren't willing to pay for decent tools.
They make enterprise software. They make mid-market solutions. They use the word "solutions" and mean it. They make CMS's. They promise that their software is so flexible that it can be customized any-which-way.
They are only compatible with IE6. They are only compatible with FireFox.
They never experiment with new languages. If it's not going to be around in 10 years, what's the point?
They never experiment with old languages. If nobody uses it anymore, what's the point?
They'll work with trendy technologies. They think that the fact that it's an AJAX-enabled Ruby-on-rails Web 2.0 Adobe-Flex Fiesta Extravaganza will make all of their shortcomings go away.
They won't budge from Waterfall. \ They hop on every management trend designed to improve the quality of their software. \ They're certified... for Quality!
They work in big companies and small companies. They pull the wool over the eyes of people who don't know better. They hire more of themselves. They respect bluster- clearly this guy knows something about C++!
They want it all in the spec. The spec is Lord and they never question the spec. To change the spec requires a 4-man team and a week of time.
They can't decide whether to add a feature or not, so they just add the feature as an 'option'.
They are in a GANTT chart.
They don't usability test. They don't load-test. By the time they do, it's too late.
They remember algorithmic complexity, but they never really understood it that well and just hope to forget as much of it as possible.
They want to work at Google. They care more about their own personal projects. This is only their day-job.
They are crappy developers. I am one of them. I try not to be one of them. It's not easy.