They have to be, to fix the bugs that they introduce. They spend endless hours burning the midnight oil, putting out fires and fighting the demons that struggle to jump out of the code. On the other hand, the good programmers are the laziest bunch out there.
They will do 10x more work to avoid doing 1x work at a given point in time, if they think that 1x has the potential to come back again as new work. They would rather spend their free time reading and arguing at slashdot.
They are innately satisfied with the world and how things work. They prefer not to question the order of things and the status quo. They rather not waste their time storing useless information in their brain. Unlike their tongue tied good programmer colleagues, many of the bad programmers have skills in various areas not directly related to programming. It is an important skill to cultivate as it helps them keep their job in the first place.
His biggest pit is that he is not interested in what he is doing. He hates change. There is only one thing that is constantly improving - his Google-ing skills since Google is his only consultant. Garfield has no clue about why the bug appeared or why it didn't appear. Having this type of a developer in-house is not as destructive as having Flash but Garfield has an effect on a team's productivity.
Differences between good and bad programmers are so obvious. Having a good programmer in the company is like tasting a bar of your favorite chocolate and the good taste never goes away.
It is always a pleasure to be acquainted with this type of programmer. A good programmer is like Robin - is very intuitive, trustworthy, acknowledges injustice and is ready to fight it. An amazing programmer is like Batman - he has been fighting the "underground" for quite some time and is always ready for a new challenge. The main difference between these two is that amazing programmer always looks forward to a challenge.
My answer more directly addresses the question as it was phrased by the other asker and will read better if you understand that. Part of me didn't want to add to this already busy topic, but the other part of me won! Why did it win; why am I bothering to add yet more words to this particular multilogue? Well, because, to some degree, I may have a slightly different take on this than the many previous commentators. Binary works great in computers: it's '1' or '0', "on" or "off.
But, it doesn't tend to work so well for human matters: "good" or "bad," "sane" or "insane," "good" or "evil," "smart" or "stupid," "fat" or "thin," "alive" or "dead? By whatever measurement schemes I choose to apply, I usually find that the answers to such stark contrasts actually lie somewhere along a continuum between one such pole and the other, not at either end. I have fought with this tendency towards polarization for quite some time, now, and my personal solution is that I find it far more useful to apply three words to any such evaluation: " to what degree!
So, my answer to your question is to suggest that you rephrase it and to ask yourself this: "To what degree am I a bad programmer? Then, once you manage to locate approximately where you are along this path, you can probably identify a point somewhat closer to the "good" end—a point where you would like to find yourself in the near future.
If you do not set that point too far away, you can probably get your hind end in gear and start moving it in that direction.
If you manage to iterate this rather simple heuristic algorithm several times, you may soon find yourself too busy programming to need to ask this question again! Oh, and you'll probably make faster progress if you start pounding code on a keyboard as quickly and often as you can; and, if you take a little break now and then, read some high quality code written by your peers! In these days of dynamic Open Source development, you have no shortage of free and exquisite code to learn from!
So, I strongly recommend to you that you try my three little words, "to what degree," and see how far in a good direction they can take you! In my opinion it's all about problem solving, the tool should be far less relevant than actually getting work done.
If I've got to solve it using MS-Access or assembly language, it's a matter of time and money, not a matter of "It can't be done". A warning sign is too much focus on the academic and "proper" way of doing things, and not enough focus on getting work done. It's important to have good understanding of programming principles and foundations rather than knowing specific technologies. Those with solid foundation will be able to learn new topics easily and will produce better code. An embedded programmer that doesn't understand interrupts very well or multitasking.
Also programmers that need to work with bit fields but don't grasp logical operations on them and shifting. An immediate recognition signal is someone saying: "I don't understand why it doesn't work. I did everything right. One thing that distinguishes a bad programmer from a newbie programmers is stubborn insistence on implementing their favorite system in whatever language and API they are working in.
None of the Java collections framework was used. The Apps he wrote in this system had lite-bar menus and would open a full window form with a row of buttons on the bottom when you navigated the lite-bar to the option. It was like a little time machine back to the s. The man was clearly a skilled developer. He knew enough that he was able to write that whole system himself in the time frame of that project.
He was also able to re-use it on a few other internal systems. But he was an awful programmer in that his code misused the features of the systems he worked on. Sign up to join this community. The best answers are voted up and rise to the top. Stack Overflow for Teams — Collaborate and share knowledge with a private group.
Create a free Team What is Teams? Learn more. When would someone be considered a bad programmer? Asked 11 years, 2 months ago. Active 9 years ago. Viewed 19k times. Because said person does not accept answers on a programming-related webpage. Kidding :- — Daniel. EvanKroske: No, that's not right Community Wiki exists to allow collaborate editing of posts.
In a lot of questions, it's impossible to accept a single answer. Not every question gets an answer that actually addresses the problem.
Active Oldest Votes. When they fail to learn from their mistakes and from peer reviews. Agreed - you've got to have a feedback loop, always learning from your mistakes. PSU well said. Just like any craft, programmers are tradesmen and are not perfect, always learning but if you fail to learn from mistakes you are not improving at your craft.
That's a very broad definition; it is not limited to programmers. It applies to scientists, cooks, sportsmen, translators, janitors, photographers, and really any profession. Everyone's a moron at least once a week. RegDwight: and your point was Net, Cocoa being too large to expect any programmer, even a good one, to learn in anything less than a few years. But a good programmer will search for a built-in function that does what they need before they begin to roll their own, and excellent programmers have the skill to break-down and identify the abstract problems in their task, then search for existing frameworks, patterns, models and languages that can be adapted before they even begin to design the program.
These are only indicative of the problem if they continue to appear in the programmer's work long after he should have mastered the new platform. A programmer can't acquire this kind of knowledge without slowing down, and it's likely that he's been in a rush to get each function working by whatever means necessary. He needs to have the platform's technical reference handy and be able to look through it with minimal effort, which can mean either having a hard copy of it on the desk right next to the keyboard, or having a second monitor dedicated to a browser.
To get into the habit initially, he should refactor his old code with the goal of reducing its instruction count by or more. If you don't understand pointers then there is a very shallow ceiling on the types of programs you can write, as the concept of pointers enables the creation of complex data structures and efficient APIs. Managed languages use references instead of pointers, which are similar but add automatic dereferencing and prohibit pointer arithmetic to eliminate certain classes of bugs.
They are still similar enough, however, that a failure to grasp the concept will be reflected in poor data-structure design and bugs that trace back to the difference between pass-by-value and pass-by-reference in method calls.
But I did know which room his acquaintance, Frank, was staying in. So I went up there and knocked on his door and asked him, 'Where's Joe staying? And that, in fact, is where Joe was. The above is a simple analogy for a linked list, and anybody can invent their own, even if they aren't programmers. The comprehension failure doesn't occur when pointers are described, so you can't describe them any more thoroughly than they already have been. It fails when the programmer then tries to visualize what's going on in the computer's memory and gets it conflated with their understanding of regular variables, which are very similar.
It may help to translate the code into a simple story to help reason about what's going on, until the distinction clicks and the programmer can visualize pointers and the data structures they enable as intuitively as scalar values and arrays.
The idea of recursion is easy enough to understand, but programmers often have problems imagining the result of a recursive operation in their minds, or how a complex result can be computed with a simple function. This makes it harder to design a recursive function because you have trouble picturing "where you are" when you come to writing the test for the base condition or the parameters for the recursive call.
Get your feet wet and be prepared for some stack overflows. Begin by writing code with only one base-condition check and one recursive call that uses the same, unmodified parameter that was passed. Stop coding even if you have the feeling that it's not enough, and run it anyway. It throws a stack-overflow exception, so now go back and pass a modified copy of the parameter in the recursive call.
More stack overflows? Excessive output? Then do more code-and-run iterations, switching from tweaking your base-condition test to tweaking your recursive call until you start to intuit how the function is transforming its input. Resist the urge to use more than one base-condition test or recursive call unless you really Know What You're Doing.
Your goal is to have the confidence to jump in, even if you don't have a complete sense of "where you are" in the imaginary recursive path. Then when you need to write a function for a real project you'd begin by writing a unit test first, and proceeding with the same technique above. Are you being paid by the line? Are you carrying over old habits from a language with a weak type system?
If neither, then this condition is similar to the inability to reason about code, but it seems that it isn't reasoning that's impaired, but trust and comfort with the language. Some of the symptoms are more like "comfort code" that doesn't survive logical analysis, but that the programmer felt compelled to write anyway. The only remedy may be more time to build up familiarity. Transitioning from imperative programming to functional and declarative programming will immediately require you to think about operating on sets of data as your primitive, not scalar values.
The transition is required whenever you use SQL with a relational database and not as an object store , whenever you design programs that will scale linearly with multiple processors, and whenever you write code that has to execute on a SIMD-capable chip such as modern graphics cards and video game consoles.
The following count only when they're seen on a platform with Declarative or Functional programming features that the programmer should be aware of.
Funny enough, visualizing a card dealer cutting a deck of cards and interleaving the two stacks together by flipping through them with his thumbs can jolt the mind into thinking about sets and how you can operate on them in bulk.
Unless you criticize your own ideas and look for flaws in your own thinking, you will miss problems that can be fixed before you even start coding. If you also fail to criticize your own code once written, you will only learn at the vastly slower pace of trial and error. This problem originates in both lazy thinking and egocentric thinking, so its symptoms seem to come from two different directions.
Start with a book like Critical Thinking by Paul and Elder, work on controlling your ego, and practice resisting the urge to defend yourself as you submit your ideas to friends and colleagues for criticism. Once you get used to other people examining your ideas, start examining your own ideas yourself and practice imagining the consequences of them.
In addition, you also need to develop a sense of proportion to have a feel for how much design is appropriate for the size of the problem , a habit of fact-checking assumptions so you don't overestimate the size of the problem , and a healthy attitude towards failure even Isaac Newton was wrong about gravity, but we still love him and needed him to try anyway.
Finally, you must have discipline. Being aware of flaws in your plan will not make you more productive unless you can muster the willpower to correct and rebuild what you're working on. When you tilt the board just right, pull back the pin to just the right distance, and hit the flipper buttons in the right sequence, then the program runs flawlessly with the flow of execution bouncing off conditionals and careening unchecked toward the next state transition.
Imagine your program's input is water. It's going to fall through every crack and fill every pocket, so you need to think about what the consequences are when it flows somewhere other than where you've explicitly built something to catch it.
You will need to make yourself familiar with the mechanisms on your platform that help make programs robust and ductile.
There are three basic kinds:. Using these ought to become second nature to you, like putting commas and periods in sentences. To get there, go through the above mechanisms the ones in parenthesis one at a time and refactor an old program to use them wherever you can cram them, even if it doesn't turn out to be appropriate especially when they don't seem appropriate, so you also begin to understand why.
If the following symptoms weren't so dangerous they'd be little more than an issue of fit-n-finish for most programs, meaning they don't make you a bad programmer, just a programmer who shouldn't work on network programs or secure systems until he's done a bit of homework.
For any system that handles or stores information of value to you or its users, or that controls a valuable resource, always have a security professional review the design and implementation. The vast majority of security failures traceable to code have been due to silly mistakes, most of which can be avoided by screening input, using resources conservatively, using common sense, and writing code no faster than you can think and reason about it. Programmers in a hurry or The Zone commit all these crimes and come back to clean it up later, but a bad programmer is just sloppy.
Sometimes it helps to use an IDE that can fix indentation and whitespace "pretty print" with a shortcut key, but I've seen programmers who can even bludgeon Visual Studio's insistence on proper indentation by messing around with the code too much. Programming could still be a hobby for you, but it would be in society's best interests to defend itself against your entry into the world of professional software development.
The compiler and runtime can often answer a question faster than a human can. Rather than seek out a senior programmer and ask them "will it work if I do this?
Are you excessively cautious? Are you only comfortable when you have permission? Has anyone ever said that you were passive aggressive? You might consider inviting some friends to visit the local Six Flags or some other roller-coaster park. If you want baptism by fire, then make your first ride the scariest. If you consider yourself ready to get off the kiddie rides you might try your hand at hang gliding and windsurfing, which have the benefit of teaching you what you can and cannot control.
Much of what makes people timid to experiment is chemical--your brain has a small number of adrenergic receptors, so a little bit of adrenaline excites your fight-or-flight reflexes too much. But consider why people grow tolerant to coffee: the caffeine's byproducts force their brain to grow more adenosine receptors. So if you force your brain to grow more adrenaline receptors then the same amount of "fear juice" will trigger a lower percentage of them.
Find some experience that scares the shit out of you, do it a few times, and you will lose your fear of venture on a physical level. Note: A programmer who "suggests wacky and unrealistic solutions" is not always a bad programmer.
It can be a sign of creative thinking from someone who assumes confirmation or correction will come from somewhere else down the line. Code is like kleenex: you use it when it's useful and throw it away when it no longer serves.
We all like to think that code-reuse is important, and while it is, it's not meant to be about raising a child. Code doesn't feel. Code doesn't care. Code will turn on you like a Frankenstein monster. Code is just bytes. Code is a liability. Konrad Lorenz, the author of On Aggression, suggested that a scientist should begin each day by throwing out one of his pet theories in order to remain sharp. Consider throwing out one of your pet algorithms or design patterns or exquisite one-line Sodoku solvers every morning to remind yourself that it's you who controls the idea, not the idea that controls you.
Find the code that you're the most proud of and delete it, now re-write it from scratch in a different way. Use a "design pattern" that confuses you, or that you hate e. If necessary, delete that after you've got it working and try again with a new pattern or language. Code, by its nature, is not just inextricably glued to its language, platform, and the APIs it consumes, but written in the form of ephemeral static charges, orientations of magnetic particles, subject to the whims of the market, Moore's Law, and your employer.
Programs are infrastructure: they're built to serve a specific need, but needs always change.
0コメント