Differences

This shows you the differences between two versions of the page.

--- principles:murphy_s_law [2020-10-12 12:41] – old revision restored (2013-02-12 21:34) 159.69.186.191
+++ principles:murphy_s_law [2020-10-12 12:41] – old revision restored (2013-02-05 17:45) 159.69.186.191
@@ Line 23: / Line 23: @@
 It is not always possible to design a system in such a way. But as systems are built and used by humans, one should strive for such "fool-proof" designs.
-There are different kinds of possible errors that can and according to ML eventually will occur in some way: Replicated data can get out of sync, invariants can be broken, preconditions can be violated, interfaces can be misunderstood, parameters can be given in the wrong order, typos can occur, values can be mixed up, etc.
+Note that Murphy's law also applies to every chunk of code. According to the paw the programmer will make mistakes while implementing the system. So it is better to implement a simple design, as this will have fewer possibilities to make implementation mistakes. Furthermore code is maintained. Bugfixes will be necessary present functionality will be changed and enhanced, so every piece of code will potentially be touched in future. So a design is better the fewer possibilities there are to introduce faults while doing maintenance work.
-Note that Murphy's law also applies to every chunk of code. According to the law the programmer will make mistakes while implementing the system. So it is better to implement a simple design, as this will have fewer possibilities to make implementation mistakes. Furthermore code is maintained. Bugfixes will be necessary present functionality will be changed and enhanced, so every piece of code will potentially be touched in future. So a design is better the fewer possibilities there are to introduce faults while doing maintenance work.
@@ Line 40: / Line 38: @@
   * Make use of static typing, so the compiler will report faults
-  * Make the design simple, so there will be fewer implementation defects (see [[Keep It Simple Stupid|KISS]])
+  * Make the design simple, so there will be fewer implementation defects (see [[Keep It Simple Stupid]])
   * Use automatic testing to find defects
-  * Avoid duplication and manual tasks, so necessary changes are not forgotten (see [[Don't Repeat Yourself|DRY]])
+  * Avoid duplication and manual tasks, so necessary changes are not forgotten (see [[Don't Repeat Yourself]])
   * Use polymorphism instead of repeated switch statements
-  * Use the same mechanisms wherever reasonably possible (see [[Uniformity Principle|UP]])
+  * Use the same mechanisms wherever reasonably possible (see [[Uniformity Principle]])
-  * Use consistent naming and models throughout the design (see [[Model Principle|MP]])
+  * Use consistent naming and models throughout the design (see [[Model Principle]])
-  * Avoid Preconditions and Invariants (see [[Invariant Avoidance Principle]])
   * ...
@@ Line 74: / Line 71: @@
   * [[Easy to Use and Hard to Misuse]] (EUHM): Because of ML an interface should be crafted so it is easy to use and hard to misuse. EUHM is the application of ML to interfaces.
   * [[Uniformity Principle]] (UP): A typical source of mistakes are differences. If similar things work similarly, they are more understandable. But if there are subtle differences in how things work, it is likely that someone will make the mistake to mix this up.
-  * [[Invariant Avoidance Principle]] (IAP): Invariants are statements that have t be true in order to keep a module in a consistent state. ML states that eventually an invariant will be broken resulting in a hard to detect defect. IAP states that invariants should therefore be avoided. So IAP is the application of ML to invariants.
 ==== Contrary Principles ====