Was giving some advice to an aspiring programmer and this sort of just came to me. Ill probably add more types of coders down the road. The noob code - Uses every whiz bang feature of the language. Every line of code is a function, or object and the documentation looks like they are trying to impress an instructor rather than giving you an idea what the code is doing. Not only is it prose, its LONG prose usually several times longer than the code and both are absolute junk. Takes you years to track down even simple changes because the code is scattered to the winds in unnecessary functions/objects. The sad thing is the noob is coding for an audience thinking how impressed people will be by their code when in reality they are the cursed. The undead of coders who dread touching their code as it takes eons to debug the strung out monstrosity. Their insecurity framed for all to see in the proud remark statements with their name or login ID in the remark statements. The obfuscicator - Learned out to use macro code and somehow believes that writing insane code = job security. If theres documentation in the code its utterly useless and variable names are single letters or very close to keywords. The spaghetti slinger - Some of the most horrific rambling code you have ever seen. Variable names have no discernable pattern. Scope may be random if the language supports it. Half the code is remarked out, the other half you wish it was because it hurts the eyes of all who gaze upon it. The worst spaghetti coders have not only not learned how to use objects and functions for repetitive code, apparently copy and paste is beyond them also as they have huge piles of redundant but not identical code. So even though its purpose is identical it still takes you time to clean sections because of idiosyncrasies about that code. The organizer - The code is neat orderly, the remark statements even make sense and usually are semi-helpful but the variable names make you want to puke. Hungarian notation is bad enough but some of these guys take Hungarian notation to a new extreme. If they are trusted with creating schemas its in 4th or 5th normal form and the functions are adorned or festooned with amazing junk. The code is slow, bulky and reads like a poorly written romance novel. There are stubs everywhere for future functionality but very little actually works. This is because the organizer makes a sloth look like a speeding rocket. The variable names exceed the human capacity to remember (12 chars, any var name longer than 12 is going to slow you down and invite mistakes as most people cannot remember more than 12 chars at once.) and worse they are so similar for the first 5-8 chars that every var on the page looks exactly the same unless you go line by line. Forget the high rez modes. You have to drop your resolution and thereby drop the amount of code on your screen dramatically and tediously scan every single line. Just to make your day even harder every loop and conditional will be done the exact same way no matter whether it makes sense to do it that way or not. The copier - These people write as little code as possible, instead they scavage code from everywhere and string it together, modifying here and there but never documenting what they modified or the code source. Reading their code is like a trip down the rabbit hole. The fresh graduate - Has no understanding of what they are doing. Actually believes the things they learned to answer MCP exams and to pass courses are practical and used in the real world. Has never written a line of code that wasnt part of a job or school asignment. The code usually works in its own way, though it is like a thundering herd of wilderbeast on LSD in how it gets there. Five lines in you know its just going to be easier, faster and better to rewrite the entire thing. The grump - Programmer who didnt want to write this particular code. If there was any doubt the remark statements remove it. Some are rather amusing, but they get kind of annoying as you read through the constant griping which you honestly could care less about. The borrower - Takes code reusual to the next level by burrowing into every API and system call they can find to avoid writing a few lines of code. In the end updates and upgrades break pieces of the code and all that fancy external stuff at best gets replaced. All too often it creates really difficult bugs to solve as the bug is actually in the external app not the actual code and is often introduced by updates, upgrades or incompatable libs so once working code not only breaks, it only breaks on certain machines. After spending days sometimes weeks trying to reproduce the bug a pattern is discovered as new machines recieve the upgrade/update which breaks the program or you get lucky and can reproduce and see a useful error message. Dependency hell and eternal bugnation are the only fruits of such efforts. The forcaster - Believes their code is invincible and has no error handling at all in it.
Posted on: Fri, 12 Dec 2014 19:28:16 +0000
Trending Topics
Recently Viewed Topics
© 2015