Principles for Managing complexity in Code

               
func addCustomerReview(review string) (error) {
   maxRetries := 3 // accidental state
   delay := 1 * time.Second  // accidental state
   for i := 0; i < maxRetries; i++ {
      // Perform the operation - essence
      err := performOperation(review)
      if err != nil {
         // Perform backoff - accidental logic
         time.Sleep(delay)
         delay = delay + 2*time.Second
         continue
      }
      return nil
   }
   return errors.New("failed to get customer reviews")
}
                
            

• Aspect oriented programming is another way to separate some of these aspects. Revisiting the example above, rather than muddying the essential logic with retry logic (which is incidental) we can separate out the retry logic in a separate function as well

                          
  // accidental logic
  func withRetryAndTimeout(aFunction func() error, maxRetries int, delay time.Duration) error {
     for i := 0; i < maxRetries; i++ {
        err := aFunction()
        if err != nil {
           time.Sleep(delay)
           delay = delay + 2*time.Second
           continue
        }
        return nil
     }
     return errors.New("failed to get customer reviews")
  }
  
  // essential logic
  func addCustomerReview(review string) error {
     return performOperation(review)
  }
  
  withRetryAndTimeout(func() error {
     return addCustomerReview("This is a great product")
  }, 3, 1*time.Second)
                          
                      

• Leverage event driven architectures. In the above example, an event can be published to add a customer review. The underlying eventing platform provides fault tolerance.

• Using linters to enforce code consistency is a small step but incurs massive benefits in the long run.
• Test Driven Development (TDD), allows to write testable code from the get-go which in-turn encourages design patterns such as dependency injection, strategy pattern, etc.
• Code scanning tools (static and dynamic) allow insights into quality of code and good practices.
• Many modern IDEs provide tools to identify duplicate or problematic code snippets.
• Last but one of the most important one: Being mindful of Separation of concerns: logic, state and control.

• The essential state is the foundation of the system and should not reference either logic or control.
• Essential logic (business rules) does not have a say in how, when and why the essential state might change.
• The essential logic specification will make no reference to any part of the incidental state, logic or control.
• Accidental State and control is conceptually least important. Changes to this should not impact any other specification but this specification can change if either essential state or logic changes. Separation of functionwithRetryAndTimeout from addCustomerReviews above is a good example of separating accidental state and control from essential state and logic.

                
func calculateCost(hireDetails HireDetails, hireCost HireCost) int {
   baseCost := hireDetails.daysOfHire * hireCost.dailyRateInCents
   discountRate := calculateDiscountRate(hireDetails.daysOfHire)


   discountedCost := float64(baseCost) * (1 - discountRate)
   return int(discountedCost) + hireCost.securityInCents
}