My experience as a programmer has taught me a few things about
writing software. Here are some things that people might find
surprising about writing code:
- A programmer spends about 10-20% of his time writing code, and most programmers write about 10-12 lines of code per day
that goes into the final product, regardless of their skill level.
Good programmers spend much of the other 90% thinking, researching, and
experimenting to find the best design. Bad programmers spend much of
that 90% debugging code by randomly making changes and seeing if they
work.
“A great lathe operator commands several times the wage of an
average lathe operator, but a great writer of software code is worth
10,000 times the price of an average software writer.” –Bill Gates - A
good programmer is ten times more productive than an average
programmer. A great programmer is 20-100 times more productive than the
average. This is not an exaggeration
– studies since the 1960′s have consistently shown this. A bad
programmer is not just unproductive – he will not only not get any work
done, but create a lot of work and headaches for others to fix. - Great programmers
spend little of their time writing code – at least code that ends up in
the final product. Programmers who spend much of their time writing
code are too lazy, too ignorant, or too arrogant to find existing
solutions to old problems. Great programmers are masters at recognizing
and reusing common patterns. Good programmers are not afraid to
refactor (rewrite) their code constantly to reach the ideal design. Bad
programmers write code which lacks conceptual integrity,
non-redundancy, hierarchy, and patterns, and so is very difficult to
refactor. It’s easier to throw away bad code and start over than to
change it. - Software obeys the laws of entropy, like everything
else. Continuous change leads to software rot, which erodes the
conceptual integrity of the original design. Software rot is
unavoidable, but programmers who fail to take conceptual integrity into
consideration create software that rots so so fast that it becomes
worthless before it is even completed. Entropic failure of conceptual
integrity is probably the most common reason for software project
failure. (The second most common reason is delivering something other
than what the customer wanted.) Software rot slows down progress
exponentially, so many projects face exploding timelines and budgets
before they are killed. - A 2004 study found that
most software projects (51%) will fail in a critical aspect, and 15%
will fail totally. This is an improvement since 1994, when 31% failed. - Although most software is made by teams
,
it is not a democratic activity. Usually, just one person is
responsible for the design, and the rest of the team fills in the
details. - Programming is hard work. It’s an intense mental
activity. Good programmers think about their work 24/7. They write
their most important code in the shower and in their dreams. Because
the most important work is done away from a keyboard, software projects
cannot be accelerated by spending more time in the office or adding more people to a project
.