This hands-on workshop teaches how to retain clean code by refactoring in the smallest possible steps so it becomes everyday practice. It will enable you to continue with much more complex refactorings towards design patterns where applicable.

This way you learn to tackle emergent design from a long term point of view. You will possess skills to make architectures more extendable and readable by applying patterns when you need them without prior over-engineering.

Attendees will gain:
* technical skills based on self live coding;
* awareness of their attitude that is always reflected in outcome code quality.

Attendees will understand:
* how the organization of work within the team/company influences final code quality;
* how patterns solve the problems at the current state of design but without continuous refactoring introduces next issues if the design is followed with copy-paste thoughts only.

Attendees will experience:
* how design patterns might enable but also impede further development for new business cases;
* a threshold of complexity behind which usage of design patterns pays off;
* by trying out ideas to experiment with adjustments to the way their development process is organized so they can improve the quality of the final product.


## More about training

Refactoring is very well known in theory. It looks like everyone has heard about it. But do we know how to approach it? Isn’t it often a theory followed by an idea to re-write a given part of code because we are afraid to touch the given code any longer?
During the workshop, we go carefully through the concept of the Pyramid of Refactoring that enables you to keep your code clean through continuous refactoring and turn the code architecture into design patterns when it brings benefits.

* Simplifying the logic of algorithms
* Extracting smaller methods
* Extracting smaller classes
* Notifying emerging design patterns
* Cleaning up the architecture

The training is mainly focused on working with code using automated refactoring features that are built into IntelliJ. The source code is based on the Java language. The trainer does all the refactorings live in small steps which allows the attendees to follow it with the same
changes on their laptops. The remaining 25% of the training is dedicated to the motivation part, how to make refactoring a daily habit in order to keep technical debt under control.

Please note also that this is a training mainly about refactoring – not necessary about which the design is the best. Different teams might prefer different architectures whereas the goal of this training is to show how easy/fast we can change the low-level design and keep the design emergent according to our architectural decisions and needs. Fortunately, the need to use some patterns is not visible at the beginning of development. This way we can avoid over-engineering and make use of patterns only when they decrease code complexity.
We do our best to keep the code simple but when the codebase is growing we begin to regret a given design pattern is missing as part of the solution.
... and this is the time to apply the refactoring to patterns, for example, to replace conditional statements with polymorphism. This way we tackle code complexity with Strategy, State, Abstract Factory or any other pattern. This approach allows us to avoid over-engineering from the beginning and refactor our codebase just in time when it brings value, decreases complexity, and saves time and money.


Effective Refactoring to Clean Code & Patterns

Learn to tackle technical debt on a daily basis. Feel the thrill of refactoring and make it a habit to maintain code readability and extendibility continuously.

Consultations