PluralSight - Advanced Defensive Programming Techniques

Files:

• Get Bonus Downloads Here.url (0.2 KB)
~Get Your Files Here ! 05. Dismissing Defensive Code by Avoiding Primitive Types
• 01. The Reasons to Avoid Enumerations.mp4 (16.0 MB)
• 01. The Reasons to Avoid Enumerations.vtt (6.9 KB)
• 02. Alternatives to Enumerations.mp4 (7.6 MB)
• 02. Alternatives to Enumerations.vtt (5.2 KB)
• 03. Converting Enumeration to a Class.mp4 (24.8 MB)
• 03. Converting Enumeration to a Class.vtt (6.4 KB)
• 04. The Reasons to Never Stringify Data.mp4 (26.6 MB)
• 04. The Reasons to Never Stringify Data.vtt (7.7 KB)
• 05. Reaping the Benefits of String Encapsulation.mp4 (15.2 MB)
• 05. Reaping the Benefits of String Encapsulation.vtt (3.3 KB)
• 06. Avoiding Primitive Types Altogether.mp4 (4.8 MB)
• 06. Avoiding Primitive Types Altogether.vtt (4.1 KB)
• 07. Example - Modeling Money.mp4 (10.7 MB)
• 07. Example - Modeling Money.vtt (4.7 KB)
• 08. Persistence - Small-scale CQRS and DDD.mp4 (9.8 MB)
• 08. Persistence - Small-scale CQRS and DDD.vtt (6.7 KB)
• 09. Demonstrating Persistence.mp4 (22.6 MB)
• 09. Demonstrating Persistence.vtt (8.7 KB)
• 10. Summary.mp4 (4.6 MB)
• 10. Summary.vtt (3.9 KB)
08. The Principle of Working with Objects, Not with Nulls
• 01. Understanding the Role of Null.mp4 (12.1 MB)
• 01. Understanding the Role of Null.vtt (5.4 KB)
• 02. Why Compilers Still Rely on Null.mp4 (11.2 MB)
• 02. Why Compilers Still Rely on Null.vtt (5.5 KB)
• 03. Do Not Return Null from a Method.vtt (8.5 KB)
• 04. Using Callback on Optional Content.mp4 (12.6 MB)
• 04. Using Callback on Optional Content.vtt (4.9 KB)
• 05. Overloading Existing APIs to Never Return Null.mp4 (14.3 MB)
• 05. Overloading Existing APIs to Never Return Null.vtt (5.9 KB)
• 06. Returning an Optional Object.mp4 (18.8 MB)
• 06. Returning an Optional Object.vtt (6.4 KB)
• 07. Implementing Custom Option Type.mp4 (18.9 MB)
• 07. Implementing Custom Option Type.vtt (6.2 KB)
• 08. Consuming the Option.mp4 (26.0 MB)
• 08. Consuming the Option.vtt (8.0 KB)
• 09. Persistence - Creating Complex Domain Objects.mp4 (22.0 MB)
• 09. Persistence - Creating Complex Domain Objects.vtt (5.6 KB)
• 10. Summary.mp4 (3.4 MB)
• 10. Summary.vtt (3.0 KB)
1. Course Overview
• 1. Course Overview.mp4 (3.2 MB)
• 1. Course Overview.vtt (1.9 KB)
10. Designing Alternative Workflows Instead of Defending from Errors
• 1. What’s Wrong with Status Codes.mp4 (12.2 MB)
• 1. What’s Wrong with Status Codes.vtt (6.8 KB)
• 2. Understanding Effects of Throwing Exceptions.mp4 (11.7 MB)
• 2. Understanding Effects of Throwing Exceptions.vtt (5.2 KB)
• 3. What Exceptions Are Not Meant to Do.mp4 (18.0 MB)
• 3. What Exceptions Are Not Meant to Do.vtt (9.3 KB)
• 4. Leave Nothing Exceptional in Exceptions.mp4 (24.5 MB)
• 4. Leave Nothing Exceptional in Exceptions.vtt (9.7 KB)
• 5. Returning a Polymorphic Type Instead of an Excep.mp4 (18.2 MB)
• 5. Returning a Polymorphic Type Instead of an Excep.vtt (6.0 KB)
• 6. Separating Positive and Negative Return Values.mp4 (19.8 MB)
• 6. Separating Positive and Negative Return Values.vtt (6.0 KB)
• 7. Inventing the Either Type.mp4 (22.5 MB)
• 7. Inventing the Either Type.vtt (7.4 KB)
• 8. Consuming the Either Type.mp4 (11.7 MB)
• 8. Consuming the Either Type.vtt (4.2 KB)
• 9. Summary.mp4 (6.8 MB)
• 9. Summary.vtt (5.7 KB)
2. Understanding Limitations of Traditional Defensive Code
• 1. The First Law of Defensive Programming.mp4 (10.9 MB)
• 1. The First Law of Defensive Programming.vtt (7.1 KB)
• 2. Version Check.mp4 (532.1 KB)
• 2. Version Check.vtt (0.0 KB)
• 3. What Follows in This Course.mp4 (17.4 MB)
• 3. What Follows in This Course.vtt (9.9 KB)
• 4. Traditional Defensive Techniques.mp4 (9.7 MB)
• 4. Traditional Defensive Techniques.vtt (7.1 KB)
• 5. Defensive Design - An Experiment.mp4 (15.9 MB)
• 5. Defensive Design - An Experiment.vtt (10.5 KB)
• 6. Called Method Cannot Defend.mp4 (10.4 MB)
• 6. Called Method Cannot Defend.vtt (8.1 KB)
• 7. Defining Function Domains.mp4 (9.6 MB)
• 7. Defining Function Domains.vtt (8.3 KB)
• 8. Summary.mp4 (3.7 MB)
• 8. Summary.vtt (3.1 KB)
3. Removing Corruption by Only Creating Consistent Objects
• 1. Creating Objects.mp4 (6.0 MB)
• 1. Creating Objects.vtt (5.1 KB)
• 2. Creating Consistent Objects.mp4 (9.9 MB)
• 2. Creating Consistent Objects.vtt (7.1 KB)
• 3. Pros and Cons of Multiple Constructors.mp4 (25.2 MB)
• 3. Pros and Cons of Multiple Constructors.vtt (8.0 KB)
• 4. Understanding Limitations of the Constructor.mp4 (9.0 MB)
• 4. Understanding Limitations of the Constructor.vtt (5.8 KB)
• 5. Promoting Constructor into Builder.mp4 (8.4 MB)
• 5. Promoting Constructor into Builder.vtt (4.2 KB)
• 6. Variations in the Builder Implementation.mp4 (24.4 MB)
• 6. Variations in the Builder Implementation.vtt (7.9 KB)
• 7. Summary.mp4 (6.6 MB)
• 7. Summary.vtt (5.1 KB)
4. Removing Corruption by Only Making Valid State Transitions
• 1. Reaping the Benefits of Constructor Validation.mp4 (19.5 MB)
• 1. Reaping the Benefits of Constructor Validation.vtt (6.3 KB)
• 2. Defending in Property Setters.mp4 (16.8 MB)
• 2. Defending in Property Setters.vtt (6.1 KB)
• 3. Understanding Distinct Kinds of Properties.mp4 (6.4 MB)
• 3. Understanding Distinct Kinds of Properties.vtt (4.0 KB)
• 4. Defending in Complex Mutations.mp4 (21.7 MB)
• 4. Defending in Complex Mutations.vtt (5.8 KB)
• 5. Function Domains Revisited.mp4 (10.9 MB)
• 5. Function Domains Revisited.vtt (5.0 KB)
• 6. When Constructor Depends on Multiple Objects.mp4 (13.4 MB)
• 6. When Constructor Depends on Multiple Objects.vtt (5.2 KB)
• 7. Creating Objects in Small Steps.mp4 (10.4 MB)
• 7. Creating Objects in Small Steps.vtt (9.0 KB)
• 8. Persistence and Parameterized Constructors.mp4 (10.8 MB)
• 8. Persistence and Parameterized Constructors.vtt (8.6 KB)
• 9. Summary.mp4 (4.5 MB)
• 9. Summary.vtt (3.6 KB)
6. Defining Function Domains as the Primary Line of Defense
• 1. Introducing Guard Clauses.mp4 (11.4 MB)
• 1. Introducing Guard Clauses.vtt (7.5 KB)
• 2. Guarding Against Null Only.mp4 (15.2 MB)
• 2. Guarding Against Null Only.vtt (8.8 KB)
• 3. Dont Guard Business Rules.mp4 (31.1 MB)
• 3. Dont Guard Business Rules.vtt (7.7 KB)
• 4. Removing Guards Through Design.mp4 (26.5 MB)
• 4. Removing Guards Through Design.vtt (6.1 KB)
• 5. Turning Domain Rules into Rule Objects.mp4 (11.0 MB)
• 5. Turning Domain Rules into Rule Objects.vtt (3.1 KB)
• 6. Turning Rule Objects into Active Elements.mp4 (26.9 MB)
• 6. Turning Rule Objects into Active Elements.vtt (6.5 KB)
• 7. Completing the Students Filter.mp4 (21.5 MB)
• 7. Completing the Students Filter.vtt (5.5 KB)
• 8. Persistence - Querying View Models.mp4 (29.9 MB)
• 8. Persistence - Querying View Models.vtt (9.4 KB)
• 9. Summary.mp4 (4.2 MB)
• 9. Summary.vtt (3.5 KB)
7. Building Defensive Design Instead of Writing Defensive Code
• 1. Encapsulating State.mp4 (17.5 MB)
• 1. Encapsulating State.vtt (9.8 KB)
• 2. Keeping Related Data Together.mp4 (20.9 MB)
• 2. Keeping Related Data Together.vtt (7.9 KB)
• 3. Turning Chained Ifs into the Chain of Rules.mp4 (20.4 MB)
• 3. Turning Chained Ifs into the Chain of Rules.vtt (7.1 KB)
• 4. Making Friends with Regular Expressions.mp4 (8.4 MB)
• 4. Making Friends with Regular Expressions.vtt (4.3 KB)
• 5. Replacing Branching with Regular Expressions.mp4 (28.9 MB)
• 5. Replacing Branching with Regular Expressions.vtt (7.5 KB)
• 6. Moving Expressions out to Configuration.mp4 (24.2 MB)
• 6. Moving Expressions out to Configuration.vtt (5.9 KB)
• 7. Persistence - Creating and Updating Domain Objects.mp4 (34.9 MB)
• 7. Persistence - Creating and Updating Domain Objects.vtt (9.9 KB)
• 8. Summary.mp4 (5.1 MB)
• 8. Summary.vtt (3.7 KB)
9. Building Rich Domain Model as an Effective Defense by Design
• 1. Reconsidering Immutable Objects.mp4 (26.2 MB)
• 1. Reconsidering Immutable Objects.vtt (9.4 KB)
• 2. Turning Classes Immutable.mp4 (12.4 MB)
• 2. Turning Classes Immutable.vtt (4.4 KB)
• 3. Avoiding Aliasing Bugs Altogether.mp4 (21.7 MB)
• 3. Avoiding Aliasing Bugs Altogether.vtt (5.6 KB)
• 4. The Downside of Immutability.mp4 (19.4 MB)
• 4. The Downside of Immutability.vtt (5.2 KB)
• 5. Constrained Mutability with Set-once Properties.mp4 (19.0 MB)
• 5. Constrained Mutability with Set-once Properties.vtt (8.3 KB)
• 6. Consuming Semi-mutable Objects.mp4 (18.4 MB)
• 6. Consuming Semi-mutable Objects.vtt (4.6 KB)
• 7. Using Historical Model.mp4 (12.6 MB)
• 7. Using Historical Model.vtt (5.9 KB)
• 8. Implementing Simple Historical Model.mp4 (38.8 MB)
• 8. Implementing Simple Historical Model.vtt (9.2 KB)
• 9. Summary.mp4 (5.8 MB)
• 9. Summary.vtt (5.0 KB)
• Bonus Resources.txt (0.4 KB)
• playlist.m3u (7.8 KB)