There are a lot of talks about developers and their whims. Maybe that’s why people started creating the jokes about tester-developer “relations”, some myths, etc. Without any doubt, there are some misconceptions about software developer profession.
The most common misconceptions are that professional developers from independent testing companies work 24/7; that one cool developer (hacker) can replace ten average developers; that modern tools show better results when performing software test services, etc. We have prepared three most impressive and, in the same way, weird misconceptions about developers.
Misconception #1. The More Eyes Will Check the Code – the Less Bugs
Open source developers like to cite the aphorism: “When a sufficient number of eyes all bugs are on the surface”.
It is sometimes referred to as Linus Law, but in reality, it was Eric s. Raymond, who created the aphorism and one of the founders of the open source movement. The idea is that open source has a natural advantage over proprietary software, because any developer can view the code, find the errors and correct them if necessary. Regretfully, this is wishful thinking. Most open source projects today are much more users than the participants. Many users are not even looking at the source code, means that the number of eyes for most projects is exaggerated. Moreover, the error detection does not mean their elimination.
Misconception #2. Cool Developers Optimize the Code Maximally
The job of the professional racing team is to their car came to the finish line before everyone else. The machine itself is important, but it is only iron, which requires careful work driver and mechanic. Do you think that this is true for computer code too? Unfortunately, manual optimization is not always the best way to get the maximum performance from your algorithm. Today is the big rarity. One of the problems is that assumptions about how programmers their code works, often erroneous. High-level languages protect the programmer from the equipment. As a result, coders can try to optimize your code so that it is often useless, and often harms the project. Most programs spend 90% of their time running to process only 10% of the code. In many cases, you are better off just trust your instruments. Don’t waste your time on unnecessary manual optimization, better take care of efficiency.
Misconception #3. Good Code – is “Elegant” Code
Like most engineers, programmers like to talk about a simple or “elegant” solution. The trouble is that this is a poor way to judge about code. What these terms mean? Is there a simple or “elegant” solution? This “elegant” code works efficiently, or is the code that uses the smallest number of rows? In a sense, finding the most “elegant” solution to the problem of programming another kind of premature optimization. The good code might not be so simple or elegant. The best code works well and without bugs. Why ask for more?
Add Comment