PLU | Java Refactoring: Best Practices (2019 EN)

Discussion in 'Programming' started by Kanka, Feb 4, 2020.

  1. Kanka

    Kanka Well-Known Member Loyal User

    Messages:
    10,447
    Likes Received:
    274
    Trophy Points:
    83
    [​IMG]

    Company: Pluralsight
    Author: Andrejs Doronins
    Full Title: Java Refactoring: Best Practices
    Year: 2019
    Language: English
    Genre: Educational: Programming
    Skill Level: Intermediate
    Price: -
    -
    Files: MP4 (+ Exercise Files, Slides .PDF, Subtitles .SRT)
    Time: 02:07:44
    Video: AVC, 1280 x 720 (1.778) at 15.000 fps, 350 kbps
    Audio: AAC at 66 Kbps, 2 channels, 44.1 KHz



    Frustrated or slowed down by messy code? Don't wait for someone else to clean it up - learn how to refactor and do it yourself! This course will walk you through what you need to know for refactoring.

    Technical debt grows with the size of any software project. Without refactoring it will eventually fail, thus refactoring may be considered an essential skill of any professional software engineer.
    In this course, Java Refactoring: Best Practices, you will learn how to efficiently refactor and produce cleaner software. First, you will see what code smells are, and why they are bad for your codebase. Then, you will explore how to recognize and refactor them using a variety of techniques to achieve cleaner and more maintainable code. Finally, you will discover the most important principles that apply to refactoring and clean code. By the end of this course, you will have the necessary skills to convert a mess into flexible and robust software, one line at a time.


    Lessons:
    1. Course Overview
    01. Course Overview
    2. Why Refactoring Matters
    02. Introduction
    03. The Art of Refactoring
    04. Code Smells
    05. Refactoring Process
    06. Prerequisites
    07. Overview of Course
    3. Splitting Bloaters
    08. Defining Bloaters
    09. Introducing the Project
    10. Long Parameter List
    11. Long Method
    12. Contrived Complexity
    13. Primitive Obsession: Preserve Whole Object
    14. Primitive Obsession: Introduce Object
    15. Data Clumps
    16. Combine Entities
    17. Primitive Obsession: What We Didn't Cover
    18. Large Class
    19. Summary
    4. Fixing Object-oriented Abusers
    20. Defining Object-oriented Abusers
    21. New Project Requirements
    22. Conditional Complexity
    23. Refused Bequest
    24. Temporary Field
    25. Alternative Classes with Different Interfaces
    26. Summary
    5. Dealing with Change Preventers
    27. Defining Change Preventers
    28. Changes to the Project
    29. Divergent Change
    30. Solution Sprawl and Shotgun Surgery
    31. Parallel Inheritance Hierarchies
    32. Summary
    6. Refactoring Couplers
    33. Introduction
    34. Feature Envy
    35. Inappropriate Intimacy
    36. Excessive Exposure
    37. Message Chain
    38. Middle Man
    39. Summary
    7. Removing Dispensables
    40. Introduction
    41. Comments
    42. Dead Code
    43. Duplicate Code
    44. Speculative Generality
    45. Lazy Class & Data Class
    46. Summary
    8. Refactoring Tips and Principles
    47. Introduction
    48. Refactoring Tips & Principles
    49. Refactoring Tools
    50. Further Material
    51. Summary


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

Share This Page