~Get Your Files Here !

  05. Dismissing Defensive Code by Avoiding Primitive Types

   01. The Reasons to Avoid Enumerations.vtt

   02. Alternatives to Enumerations.vtt

   03. Converting Enumeration to a Class.vtt

   04. The Reasons to Never Stringify Data.vtt

   05. Reaping the Benefits of String Encapsulation.vtt

   06. Avoiding Primitive Types Altogether.vtt

   07. Example - Modeling Money.vtt

   08. Persistence - Small-scale CQRS and DDD.vtt

   09. Demonstrating Persistence.vtt

   10. Summary.vtt

  08. The Principle of Working with Objects, Not with Nulls

   01. Understanding the Role of Null.vtt

   02. Why Compilers Still Rely on Null.vtt

   04. Using Callback on Optional Content.mp4

   05. Overloading Existing APIs to Never Return Null.mp4

   06. Returning an Optional Object.mp4

   07. Implementing Custom Option Type.mp4

   08. Consuming the Option.mp4

   09. Persistence - Creating Complex Domain Objects.mp4

   10. Summary.mp4

  1. Course Overview

   1. Course Overview.vtt

  10. Designing Alternative Workflows Instead of Defending from Errors

   1. What’s Wrong with Status Codes.vtt

   2. Understanding Effects of Throwing Exceptions.vtt

   3. What Exceptions Are Not Meant to Do.vtt

   4. Leave Nothing Exceptional in Exceptions.vtt

   5. Returning a Polymorphic Type Instead of an Excep.vtt

   6. Separating Positive and Negative Return Values.vtt

   7. Inventing the Either Type.vtt

   8. Consuming the Either Type.vtt

   9. Summary.vtt

  2. Understanding Limitations of Traditional Defensive Code

   1. The First Law of Defensive Programming.vtt

   2. Version Check.vtt

   3. What Follows in This Course.vtt

   4. Traditional Defensive Techniques.vtt

   5. Defensive Design - An Experiment.vtt

   6. Called Method Cannot Defend.vtt

   7. Defining Function Domains.vtt

   8. Summary.vtt

  3. Removing Corruption by Only Creating Consistent Objects

   1. Creating Objects.vtt

   2. Creating Consistent Objects.vtt

   3. Pros and Cons of Multiple Constructors.vtt

   4. Understanding Limitations of the Constructor.vtt

   5. Promoting Constructor into Builder.vtt

   6. Variations in the Builder Implementation.vtt

   7. Summary.vtt

  4. Removing Corruption by Only Making Valid State Transitions

   1. Reaping the Benefits of Constructor Validation.vtt

   2. Defending in Property Setters.vtt

   3. Understanding Distinct Kinds of Properties.vtt

   4. Defending in Complex Mutations.vtt

   5. Function Domains Revisited.vtt

   6. When Constructor Depends on Multiple Objects.vtt

   7. Creating Objects in Small Steps.vtt

   8. Persistence and Parameterized Constructors.vtt

   9. Summary.vtt

  6. Defining Function Domains as the Primary Line of Defense

   1. Introducing Guard Clauses.vtt

   2. Guarding Against Null Only.vtt

   3. Dont Guard Business Rules.vtt

   4. Removing Guards Through Design.vtt

   5. Turning Domain Rules into Rule Objects.vtt

   6. Turning Rule Objects into Active Elements.vtt

   7. Completing the Students Filter.vtt

   8. Persistence - Querying View Models.vtt

   9. Summary.vtt

  7. Building Defensive Design Instead of Writing Defensive Code

   1. Encapsulating State.vtt

   2. Keeping Related Data Together.vtt

   3. Turning Chained Ifs into the Chain of Rules.vtt

   4. Making Friends with Regular Expressions.vtt

   5. Replacing Branching with Regular Expressions.vtt

   6. Moving Expressions out to Configuration.vtt

   7. Persistence - Creating and Updating Domain Objects.vtt

   8. Summary.vtt

  9. Building Rich Domain Model as an Effective Defense by Design

   1. Reconsidering Immutable Objects.vtt

   2. Turning Classes Immutable.vtt

   3. Avoiding Aliasing Bugs Altogether.vtt

   4. The Downside of Immutability.vtt

   5. Constrained Mutability with Set-once Properties.vtt

   6. Consuming Semi-mutable Objects.vtt

   7. Using Historical Model.vtt

   8. Implementing Simple Historical Model.vtt

   9. Summary.vtt

  playlist.m3u