Software Peter principle

Publié le 12 août 2011

Article de Wiki que m'a transmis un chef de projet...

A propos de Coopil : Formation management de projet. Téléchargement livres blancs Projet stratégique & Gouvernance de projets

The software Peter principle is used in software engineering to describe a dying project which has little by little become too complex to be understood even by its own developers.
It is well known in the industry as a silent killer of projects, and by the time the symptoms arise it is often too late to do anything about it. Good managers can avoid this disaster by establishing clear coding practices where unnecessarily complicated code and design is avoided.
The name is used in the book C++ FAQs (see below), and is derived from the Peter Principle — a theory about incompetence in hierarchical organizations.

Causes
Loss of Conceptual Integrity
The conceptual integrity of software is a measure of how well software conforms to a single, simple set of design principles, according to The Mythical Man Month by Fred Brooks. When done properly, it provides the most functionality using the simplest idioms. It makes software easier to use by making it simple to create and learn.
Conceptual integrity is achieved when the software’s design proceeds from a small number of agreeing individuals. For software to maintain conceptual integrity, the design must be controlled by a single, small group.
In projects without a strong software architecture team, the task of design is often combined with the task of implementation and is implicitly delegated among the individual software developers. Under these circumstances, developers are less likely to sacrifice personal interests in favor of the interests of the product. The complexity of the product grows as a result of developers adding new designs and altering earlier ones to reflect changes in fashion and individual taste.

Programmer Incompetence
The best software developers understand the importance of communicating with people over communicating with the computer, according to Code Complete by Steve McConnell. On average, 85 percent of a programmer's time is spent communicating with people, while only 15 percent is spent communicating with the computer. Maintenance programmers spend 50 to 60 percent of their time trying to understand the code they have to maintain and a software program will have, on average, 10 generations of maintenance programmers in its lifetime.
McConnell states that less competent developers favor code with advanced programming language features over code that is readable. Code written by these programmers tends to increase software complexity.

Programmer Inexperience
Inexperienced programmers sometimes make implementation choices that work but have unintended negative consequences. The most common of these mistakes are cataloged and referred to as smells in the book Refactoring by Martin Fowler. Over time, many such implementation choices degrade the software’s design; making it increasingly difficult to understand.

The Peter Principle Proven
In case you've ever wondered why ignorance rises to the executive level, here is a simple explanation that is also a mathematical proof:
Knowledge is Power.
Time is Money.
And, as every actuary (with some physics training) knows:

Work
---------- = Power
Time

So, if
Knowledge = Power
and
Time = Money
then through simple substitutions,

Work
---------- = Knowledge
Money

Solving for Money, we get:
Work
-------------- = Money
Knowledge

Thus, If Work is held constant as a positive number (no matter how small!) Money approaches infinity as Knowledge approaches zero.
What this means is:
All else being equal, the less you know, the more you make

Partager cette info :

• Facebook
• RSS
• Twitter
• Netvibes
• Email
• Delicious