Refactoring is theoretically very well-known concept. Virtually everyone has heard of it. Do we know, however, how to approach it in practice? Does not it often happen, that behind the theory there is a desire to write a new code because we do not like it anymore or it is not even suitable for reading and quick understanding anymore? This practical course will show you how to approach refactoring in the smallest possible steps, making it our everyday practice. The course is designed to motivate the software developers to work together and individually on the quality of the code every day – which is needed to deliver a high value code.
The concept of refactoring pyramid will be presented during the course.

● Understanding Algorithm
● Extraction of smaller methods
● Extraction of smaller classes
● Noticing the relationship between the classes (and the emergence of design patterns)
● Classification of architecture (packages)

The course focuses primarily on working with the source code using built-in automated refactoring in tools such as IntelliJ or Eclipse. The source code is written in Java. The trainer performs all of the refactoring transformations live, and then the participants can experience the same by working with the same code on their own laptops. The remaining 25% of the time is devoted to presentation and discussion aimed at making refactoring an everyday habit of every software developer / team.
This course is not an architecture training. Different teams may have different preferences concerning architectural solutions. The aim is to learn an easy and fast way in which you can change the code architecture from one approach to another.

Part 1
1. Learning a simple piece of code that you can understand easily and quickly
2. Discussion on how simple and fast you can expand such a piece of code by copy-paste, simultaneously reducing its legibility
3. Division of the code into smaller parts (methods, classes, interfaces) using the Pyramid of Refactoring approach
4. Learning Embedded Automated Refactoring in IntelliJ or Eclipse environment
5. SOLID principles as the basis for the division of architecture into smaller parts

Part 2
1. Getting familiar with the code from Part 1, where new functionality has been added without any refactoring
2. Presentation of another additional functionality that we want to add to the project
3. Discussion on how we can do it quickly while still reducing the legibility and quality of the code
4. “Extraction of extension points” as a result of “refactoring journey” using the Pyramid of Refactoring concept
5. Delivering new functionality as a new implementation of the “extension point” with the use of TDD

The training course is very intensive and based on experience (i.e. carrying it many times) the proposed schedule is 2 days / 4 hours per day. Such schedule will also allow the software developers to return to their daily activities for the rest of the day. On request, the training course may also take 1 day (very intensive) or be extended to two full days.

Level: beginner or intermediate, although more experienced software developers repeatedly claimed that they had learned many new things they could then share with the team. During training you will learn how to start with the smallest refactoring, and then notice the design patterns that emerge from the relationship between the smaller classes.
“Refactoring to patterns” is the subject of the second part of this training.