| 01. The Reasons to Avoid Enumerations.mp4 | 16 MB | ||
| 01. The Reasons to Avoid Enumerations.vtt | 6.9 KB | ||
| 01. Understanding the Role of Null.mp4 | 12.1 MB | ||
| 01. Understanding the Role of Null.vtt | 5.4 KB | ||
| 02. Alternatives to Enumerations.mp4 | 7.6 MB | ||
| 02. Alternatives to Enumerations.vtt | 5.2 KB | ||
| 02. Why Compilers Still Rely on Null.mp4 | 11.2 MB | ||
| 02. Why Compilers Still Rely on Null.vtt | 5.5 KB | ||
| 03. Converting Enumeration to a Class.mp4 | 24.8 MB | ||
| 03. Converting Enumeration to a Class.vtt | 6.4 KB | ||
| 03. Do Not Return Null from a Method.vtt | 8.5 KB | ||
| 04. The Reasons to Never Stringify Data.mp4 | 26.6 MB | ||
| 04. The Reasons to Never Stringify Data.vtt | 7.7 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 | ||
| 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 | ||
| 06. Returning an Optional Object.mp4 | 18.8 MB | ||
| 06. Returning an Optional Object.vtt | 6.4 KB | ||
| 07. Example - Modeling Money.mp4 | 10.7 MB | ||
| 07. Example - Modeling Money.vtt | 4.7 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 MB | ||
| 08. Consuming the Option.vtt | 8 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 | ||
| 09. Persistence - Creating Complex Domain Objects.mp4 | 22 MB | ||
| 09. Persistence - Creating Complex Domain Objects.vtt | 5.6 KB | ||
| 1. Course Overview.mp4 | 3.2 MB | ||
| 1. Course Overview.vtt | 1.9 KB | ||
| 1. Creating Objects.mp4 | 6 MB | ||
| 1. Creating Objects.vtt | 5.1 KB | ||
| 1. Encapsulating State.mp4 | 17.5 MB | ||
| 1. Encapsulating State.vtt | 9.8 KB | ||
| 1. Introducing Guard Clauses.mp4 | 11.4 MB | ||
| 1. Introducing Guard Clauses.vtt | 7.5 KB | ||
| 1. Reaping the Benefits of Constructor Validation.mp4 | 19.5 MB | ||
| 1. Reaping the Benefits of Constructor Validation.vtt | 6.3 KB | ||
| 1. Reconsidering Immutable Objects.mp4 | 26.2 MB | ||
| 1. Reconsidering Immutable Objects.vtt | 9.4 KB | ||
| 1. The First Law of Defensive Programming.mp4 | 10.9 MB | ||
| 1. The First Law of Defensive Programming.vtt | 7.1 KB | ||
| 1. What’s Wrong with Status Codes.mp4 | 12.2 MB | ||
| 1. What’s Wrong with Status Codes.vtt | 6.8 KB | ||
| 10. Summary.mp4 | 3.4 MB | ||
| 10. Summary.vtt | 3 KB | ||
| 2. Creating Consistent Objects.mp4 | 9.9 MB | ||
| 2. Creating Consistent Objects.vtt | 7.1 KB | ||
| 2. Defending in Property Setters.mp4 | 16.8 MB | ||
| 2. Defending in Property Setters.vtt | 6.1 KB | ||
| 2. Guarding Against Null Only.mp4 | 15.2 MB | ||
| 2. Guarding Against Null Only.vtt | 8.8 KB | ||
| 2. Keeping Related Data Together.mp4 | 20.9 MB | ||
| 2. Keeping Related Data Together.vtt | 7.9 KB | ||
| 2. Turning Classes Immutable.mp4 | 12.4 MB | ||
| 2. Turning Classes Immutable.vtt | 4.4 KB | ||
| 2. Understanding Effects of Throwing Exceptions.mp4 | 11.7 MB | ||
| 2. Understanding Effects of Throwing Exceptions.vtt | 5.2 KB | ||
| 2. Version Check.mp4 | 532.1 KB | ||
| 2. Version Check.vtt | 0 B | ||
| 3. Avoiding Aliasing Bugs Altogether.mp4 | 21.7 MB | ||
| 3. Avoiding Aliasing Bugs Altogether.vtt | 5.6 KB | ||
| 3. Dont Guard Business Rules.mp4 | 31.1 MB | ||
| 3. Dont Guard Business Rules.vtt | 7.7 KB | ||
| 3. Pros and Cons of Multiple Constructors.mp4 | 25.2 MB | ||
| 3. Pros and Cons of Multiple Constructors.vtt | 8 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 | ||
| 3. Understanding Distinct Kinds of Properties.mp4 | 6.4 MB | ||
| 3. Understanding Distinct Kinds of Properties.vtt | 4 KB | ||
| 3. What Exceptions Are Not Meant to Do.mp4 | 18 MB | ||
| 3. What Exceptions Are Not Meant to Do.vtt | 9.3 KB | ||
| 3. What Follows in This Course.mp4 | 17.4 MB | ||
| 3. What Follows in This Course.vtt | 9.9 KB | ||
| 4. Defending in Complex Mutations.mp4 | 21.7 MB | ||
| 4. Defending in Complex Mutations.vtt | 5.8 KB | ||
| 4. Leave Nothing Exceptional in Exceptions.mp4 | 24.5 MB | ||
| 4. Leave Nothing Exceptional in Exceptions.vtt | 9.7 KB | ||
| 4. Making Friends with Regular Expressions.mp4 | 8.4 MB | ||
| 4. Making Friends with Regular Expressions.vtt | 4.3 KB | ||
| 4. Removing Guards Through Design.mp4 | 26.5 MB | ||
| 4. Removing Guards Through Design.vtt | 6.1 KB | ||
| 4. The Downside of Immutability.mp4 | 19.4 MB | ||
| 4. The Downside of Immutability.vtt | 5.2 KB | ||
| 4. Traditional Defensive Techniques.mp4 | 9.7 MB | ||
| 4. Traditional Defensive Techniques.vtt | 7.1 KB | ||
| 4. Understanding Limitations of the Constructor.mp4 | 9 MB | ||
| 4. Understanding Limitations of the Constructor.vtt | 5.8 KB | ||
| 5. Constrained Mutability with Set-once Properties.mp4 | 19 MB | ||
| 5. Constrained Mutability with Set-once Properties.vtt | 8.3 KB | ||
| 5. Defensive Design - An Experiment.mp4 | 15.9 MB | ||
| 5. Defensive Design - An Experiment.vtt | 10.5 KB | ||
| 5. Function Domains Revisited.mp4 | 10.9 MB | ||
| 5. Function Domains Revisited.vtt | 5 KB | ||
| 5. Promoting Constructor into Builder.mp4 | 8.4 MB | ||
| 5. Promoting Constructor into Builder.vtt | 4.2 KB | ||
| 5. Replacing Branching with Regular Expressions.mp4 | 28.9 MB | ||
| 5. Replacing Branching with Regular Expressions.vtt | 7.5 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 KB | ||
| 5. Turning Domain Rules into Rule Objects.mp4 | 11 MB | ||
| 5. Turning Domain Rules into Rule Objects.vtt | 3.1 KB | ||
| 6. Called Method Cannot Defend.mp4 | 10.4 MB | ||
| 6. Called Method Cannot Defend.vtt | 8.1 KB | ||
| 6. Consuming Semi-mutable Objects.mp4 | 18.4 MB | ||
| 6. Consuming Semi-mutable Objects.vtt | 4.6 KB | ||
| 6. Moving Expressions out to Configuration.mp4 | 24.2 MB | ||
| 6. Moving Expressions out to Configuration.vtt | 5.9 KB | ||
| 6. Separating Positive and Negative Return Values.mp4 | 19.8 MB | ||
| 6. Separating Positive and Negative Return Values.vtt | 6 KB | ||
| 6. Turning Rule Objects into Active Elements.mp4 | 26.9 MB | ||
| 6. Turning Rule Objects into Active Elements.vtt | 6.5 KB | ||
| 6. Variations in the Builder Implementation.mp4 | 24.4 MB | ||
| 6. Variations in the Builder Implementation.vtt | 7.9 KB | ||
| 6. When Constructor Depends on Multiple Objects.mp4 | 13.4 MB | ||
| 6. When Constructor Depends on Multiple Objects.vtt | 5.2 KB | ||
| 7. Completing the Students Filter.mp4 | 21.5 MB | ||
| 7. Completing the Students Filter.vtt | 5.5 KB | ||
| 7. Creating Objects in Small Steps.mp4 | 10.4 MB | ||
| 7. Creating Objects in Small Steps.vtt | 9 KB | ||
| 7. Defining Function Domains.mp4 | 9.6 MB | ||
| 7. Defining Function Domains.vtt | 8.3 KB | ||
| 7. Inventing the Either Type.mp4 | 22.5 MB | ||
| 7. Inventing the Either Type.vtt | 7.4 KB | ||
| 7. Persistence - Creating and Updating Domain Objects.mp4 | 34.9 MB | ||
| 7. Persistence - Creating and Updating Domain Objects.vtt | 9.9 KB | ||
| 7. Summary.mp4 | 6.6 MB | ||
| 7. Summary.vtt | 5.1 KB | ||
| 7. Using Historical Model.mp4 | 12.6 MB | ||
| 7. Using Historical Model.vtt | 5.9 KB | ||
| 8. Consuming the Either Type.mp4 | 11.7 MB | ||
| 8. Consuming the Either Type.vtt | 4.2 KB | ||
| 8. Implementing Simple Historical Model.mp4 | 38.8 MB | ||
| 8. Implementing Simple Historical Model.vtt | 9.2 KB | ||
| 8. Persistence - Querying View Models.mp4 | 29.9 MB | ||
| 8. Persistence - Querying View Models.vtt | 9.4 KB | ||
| 8. Persistence and Parameterized Constructors.mp4 | 10.8 MB | ||
| 8. Persistence and Parameterized Constructors.vtt | 8.6 KB | ||
| 8. Summary.mp4 | 5.1 MB | ||
| 8. Summary.vtt | 3.7 KB | ||
| 9. Summary.mp4 | 5.8 MB | ||
| 9. Summary.vtt | 5 KB | ||
| Bonus Resources.txt | 409.6 B | ||
| Get Bonus Downloads Here.url | 204.8 B | ||
| playlist.m3u | 7.8 KB | ||
| ▲ 162 total files | |||
Advanced Defensive Programming Techniques
https://FreeCourseWeb.com
Last updated 11/2024
By Zoran Horvat
MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz, 2 Ch
Level: Intermediate | Genre: eLearning | Language: English + subtitle | Duration: 6h 22m | Size: 1.2 GB
This course will lead you step by step through the process of developing defensive design practices, which can substitute common defensive coding, for the better of software design and implementation.
How often do you have to defend from nulls, zeros, surprising cases hitting switch instruction, impossible else branches, and so on? Is your life a struggle with issues caused by unexpected data or invalid system state? In this course, Advanced Defensive Programming Techniques, you'll learn how to defend by means of design, so that almost all explicit defensive code can be happily removed. First, you'll discover how to build validation. Next, you'll explore how exactly to design a public interface. Finally, you'll cover how to unify error flows, so nothing unpredictable can take you by surprise. By the end of this course, you'll have the necessary knowledge to efficiently develop your own defensive design practice.
| torrent name | size | uploader | age | seed | leech |
|---|---|---|---|---|---|
| 413.8 MB | SunRiseZone | 2 years | 8 | 0 | |
| 805.8 MB | freecoursewb | 3 years | 2 | 2 | |
| 571 MB | freecoursewb | 3 years | 0 | 0 | |
| 55.7 MB | freecoursewb | 4 years | 0 | 0 | |
|
[ FreeCourseWeb ] Pluralsight - Advanced Reusable Styles and Themes in WPF Posted by
freecoursewb in Other
|
580.2 MB | freecoursewb | 4 years | 0 | 0 |
All Comments