PLU | Implementing Design Patterns Using Java 8 Lambda (2019 EN)

Discussion in 'Programming' started by Kanka, Jul 27, 2019.

  1. Kanka

    Kanka Well-Known Member Loyal User

    Messages:
    16,086
    Likes Received:
    446
    Trophy Points:
    83
    [​IMG]

    Company: Pluralsight
    Author: Jose Paumard
    Full Title: Implementing Design Patterns Using Java 8 Lambda
    Year: 2019
    Language: English
    Genre: Educational: Application Development
    Skill Level: Intermediate
    Price: -
    -
    Files: MP4 (+ Slides .PDF, Subtitles .SRT)
    Time: 03:08:19
    Video: AVC, 1280 x 720 (1.778) at 30.000 fps, 250 kbps
    Audio: AAC at 96 Kbps, 2 channels, 48.0 KHz



    Being able to design simple and fluent API to make your business applications easier to read is what you will get by following this course. All the tools brought by Java 8 to implement the standard Design Patterns are covered with many live demos.

    As a Java developer, mastering the standard design patterns from the Gang of Four book allows you to create better business applications, more robust and easier to maintain in the long run. In this course, Implementing Design Patterns Using Java 8 Lambda, you will learn how you can leverage the tools Java 8 added to the platform to write better code: easier to read and with better performances. These tools bring several functional programming paradigms to the Java language: function chaining and composition, and partial application. First, you will study how these tools have been used to improve the JDK itself through several examples including the Comparator API. Then you will see how you can use the same approach to implement several patterns on live demo examples, including the Factory, the Builder, the Singleton, and the Registry, following the principles of clean code. You will even implement the Visitor pattern in a functional and non-intrusive way. Finally, you will apply those principles to create your own Validator, purely functional and fluent. Mastering these techniques will help you creating performant, readable and versatile Java applications.

    Lessons:
    1. Course Overview
    01. Course Overview
    2. Introducing Default Methods to Chain and Compose Functions
    02. Introducing the Course: Designing API with Functional Interfaces
    03. Who Are You? What Should You Know to Follow this Course?
    04. Introducing the Agenda of the Course and This Module
    05. Creating Default Methods to Chain Consumers as Lambda Expressions
    06. Implementing the Consumer.andThen Method to Chain Consumers
    07. Preventing the Chaining of Corrupted Lambdas Using Exceptions
    08. Wrapping up the Use of Default Methods to Chain Lamdbas
    09. Leveraging Default Methods to Combine Predicates
    10. Implementing the Predicate.and Logical Operator
    11. Negating a Predicate with a Predicate.negate Default Method
    12. Wrapping up the Use of Default Methods to Combine Lamdbas
    13. Setting up the Generic Types of a Chained Function
    14. Implementing the Chaining of Functions with Default Methods
    15. Understanding the Difference between Chaining and Composing
    16. Using Static Methods on Functional Interfaces to Create Lambdas
    17. Checking the Real Functional Interfaces from the JDK
    18. Module Wrap Up
    3. Using Function Composition and Chaining to Build Comparators
    19. Introducing the Module and Its Agenda
    20. Writing a Comparator of Person Comparing Their Names
    21. Creating a Factory Method of Comparators Using a Key Extractor
    22. Reversing a Comparator with the User of a Default Method
    23. Making the Factory Method Generic to Accept Any Comparable Object
    24. Wrapping up the Creation of Comparators Using Key Extractors
    25. Leveraging Default Methods to Combine Comparators
    26. Improving the Design of the API to Make It Fluent
    27. Checking the Real Comparator Interface from the JDK
    28. Module Wrap Up
    4. From Factory and Registry to Builder Using Lambda Expressions
    29. Introducing the Module and Its Agenda
    30. Creating a Factory by Extending the Supplier Functional Interface
    31. Adding Functionalities to a Factory Using Default Methods
    32. Extending the Factory to Handle Constructor with Parameters
    33. Making the Factory Fluent Using Generics and Method References
    34. Updating the Factory to Implement the Singleton Pattern
    35. Wrapping up the Factory and Singleton Patterns Using Lambdas
    36. Introducing the Registry and the Builder Pattern
    37. Designing an API to Create a Registry Using the Builder Pattern
    38. Introducing the Registry and the Builder Examples
    39. Writing the Registration of a Factory Using a Consumer of Builder
    40. Making the Registry Functional to Implement It Using a Lambda
    41. Testing the Registry to Create Different Kind of Shapes
    42. Controlling Missing Keys with Exceptions Defined at the API Level
    43. Wrapping up the Registry and Builder Built with Lambda Example
    44. Module Wrap Up
    5. Implementing The Visitor Pattern Using Functions and Composition
    45. Introducing the Module and Its Agenda
    46. Adding Operations on Classes Using the Visitor Pattern
    47. Organizing a Simple Object Model to Implement the Visitor Pattern
    48. Writing a Visitable Set of Classes along with a Visitor
    49. Adding Methods on a Class without Changing It Using Lambdas
    50. Writing the Lambda Visitor Pattern on the Car Model Object
    51. Adding the Static and Default Methods for the Pattern to Compile
    52. Implementing the Registry of Types to Be Visited and Functions
    53. Running the Pattern with the Initialized Registry
    54. Adding a Second Element to the Registry: A First Version
    55. Fixing the Multi Element Registry with the Chaining of Consumers
    56. Making this Visitor Pattern Type Safe Using Gnerics
    57. Module Wrap Up
    6. Using Partial Application and Lambdas to Build Validators
    58. Introducing the Module and Its Agenda
    59. Setting up a Person Bean with Two Validation Rules
    60. Understanding the Validation Rules and Setting up Examples
    61. Writing the Validator Pattern in the Case of a Person Bean
    62. Implementing the Validator Interface in the Case of a Valid Bean
    63. Extending the Validator to Handle One Violated Rule
    64. Introducing the SuppressedExceptions to Wrap Exceptions Together
    65. Handling Several Exceptions with the Suppressed Exceptions
    66. Module and Course Wrap Up


    -------------