Refactoring Legacy Code Like A Pro: A Use Case.

Master The Art of Refactoring Messy Codebases Into a Software Masterpiece.

What you'll learn

Learn how to spot refactoring signals.

Learn techniques to improve the test coverage.

Master refactoring principles and best practices.

You'll confidently tackle complex legacy codebases.

Requirements

Some coding experience

Description

Master The Art of Refactoring Messy Codebases Into a Software Masterpiece and Become the go-to expert for codebase transformations by learning to take messy code as an opportunity to innovate and grow.But what is legacy code in the first place? Legacy code refers to software code or applications that were created in the past and have been in use for a significant period. However, such code often poses challenges because it may be outdated, poorly documented, or not aligned with current coding standards and best practices. These challenges can make it difficult to maintain, update, or extend the software, thereby causing potential problems for developers to refactor to make it easy for future work.In his Amazing book Working Effectively With Legacy Code, According to Michael Feathers, Legacy Code refers to any code that lacks automated tests: To me, legacy code is simply code without tests.In this course, we will explore practical ways of dealing with legacy codebases. Our approach covers everything from automated tests to detailed techniques for making codebases flexible and enjoyable to work with.By the end of the course…You'll spot refactoring signals.You'll be able to cover legacy code with tests.You'll master refactoring principles and best practices.You'll master techniques to improve the test coverage.You'll identify common code smells and anti-patterns.You'll confidently tackle complex legacy codebases.Before You BUY This CourseIf you're new to the world of code refactoring and looking for an affordable starting point, we recommend diving into specific books on the subject. Books (less than 60$) such as Refactoring or Working Effectively with Legacy Code provide a cost-effective way to build a strong foundation in refactoring principles, allowing you to learn at your own pace.Once you're ready to put your knowledge into action on real legacy code, our comprehensive course guides you through practical application and advanced techniques, ensuring you're fully equipped to tackle complex code bases confidently.What's the Use case? In this course, we will refactor a codebase that calculates prayer times provided by Prayer Times Organization. We will address the challenges posed by outdated technologies, inadequate code organization, and the need to improve code readability.With clear objectives in mind, we'll break down the refactoring process into manageable steps, including:Code analysis.Test setup.Modularization.Extracting meaningful abstraction.Reducing the clutter.Emphasizing best practices.And much more.The use case presents a good enough complex code to showcase the difficulties you can face when refactoring a real project. By the end of the course, you'll be well-prepared to take on real-world refactoring projects with confidence and expertise.You can check the preview up in a video for a full explanation of the domain problem, so if that excites you, join now, and let us refactor a messy codebase.Language AgnosticThis course is designed to be language-agnostic, meaning you can acquire essential principles and techniques that apply universally across various codebases in different programming languages.While our use cases in the course choose Kotlin, you can still find on the domain problem website other versions that apply to Java, Python, C#, C++, and PHP; the skills and insights you gain are easily transferable to any other language.We emphasize Kotlin to provide a practical learning experience, but the knowledge you acquire will empower you to excel in legacy code refactoring, regardless of your chosen programming language.

Overview

Section 1: Introduction

Lecture 1 Course Introduction

Lecture 2 Domain Problem

Lecture 3 Extra Resources

Section 2: Testing

Lecture 4 Project Setup

Lecture 5 Test Coverage

Lecture 6 Parametrized Tests

Lecture 7 Complete Code Coverage

Lecture 8 Test Cleaning

Lecture 9 Mutation Testing

Section 3: 1st Round of Refactoring: The Fundamentals

Lecture 10 Kotlin Conversion

Lecture 11 Why Refactoring?

Lecture 12 Declutter

Lecture 13 Top Level Functions

Lecture 14 Primitive Obsession

Lecture 15 Depending on Abstractions

Lecture 16 Function Splitting

Lecture 17 Capturing Logic

Lecture 18 Helping Other Devs

Lecture 19 Action to Calculation

Lecture 20 Public API

Lecture 21 Pair Programming

Section 4: 2nd Round of Refactoring: Overengineering

Lecture 22 Extracting The Responsibility of Formatting

Lecture 23 Simplifying Format Utils

Lecture 24 Refactoring The Core Logic

Lecture 25 Refactoring The Core Logic 2

Lecture 26 Refactoring The Core Logic 3

Lecture 27 Refactoring The Core Logic 4

Lecture 28 Scratch Refactoring

Section 5: Conclusion & Feedback

Lecture 29 Wrap-up

Beginner Developers wanting to learn new skill