stability.theory.txt

             
   STABILITY  
             



STABILITY/ROBUSTNESS ==>          #Making interface predictable, i.e. avoiding errors, including with erronous input
                                  #Pros:
                                  #  - correctness
                                  #Cons:
                                  #  - less flexibility
                                  #  - increased complexity

ROBUSTNESS PRINCIPLE ==>          #Also called "Postel's law"
                                  #Increase robustness by:
                                  #  - being liberal in input
                                  #     - benefit: reduces erratic behavior due to wrong input
                                  #     - problems:
                                  #        - harder to implement|maintain
                                  #        - less consistency among different implementations of the same interface
                                  #  - being strict in output
                                  #E.g. with design by contract:
                                  #  - less preconditions, exceptions
                                  #  - more postconditions, invariants

DESIGN BY CONTRACT ==>            #Increase robustness by defining input, output and side effects:
                                  #  - preconditions:
                                  #     - required condition to run function
                                  #     - ex:
                                  #        - arguments types, concepts|interfaces, constraints
                                  #        - arity
                                  #  - postconditions:
                                  #     - required condition after function has run
                                  #     - does not emcompass side effects
                                  #     - ex:
                                  #        - return values types, concepts|interfaces, constraints
                                  #        - arguments state change
                                  #           - class functions pass "this" as implicit argument, so includes class state change
                                  #  - invariants:
                                  #     - like postconditions but the condition is that it did not change
                                  #     - can change in-between providing: temporariy, thread-safe, exception-safe
                                  #     - ex: const variables
                                  #  - side effects: global state changes
                                  #  - exceptions:
                                  #     - which exceptions are thrown. If any:
                                  #        - is the function exception-safe
                                  #        - postconditions are not guaranteed, but invariants should be
                                  #  - time complexity
                                  #Can be:
                                  #  - documented
                                  #  - enforced compile-time or runtime

COMPATIBILITY ==>                 #See compatibility doc

TESTABILITY ==>                   #See testing doc

SECURITY ==>                      #See security doc