Design Patterns with Spring
The purpose of this course is to help developers design well-crafted code.
Meaning expressive, concise design that is also flexible and testable. The course is a mix of theory, brainstorms and hands-on exercises designed to teach developers practical techniques they can immediately apply to real-world projects.
Why this workshop?
Design Patterns are a powerful weapon. So powerful that in the wrong hands it can get you to horrible overengineered code. Mastering the underlying principles and knowing why, how, the cost and nuances of applying a pattern can have a huge impact on code quality on the long run.
Since the classic GoF book, design patterns have evolved dramatically: many have died, a few amazing ones were born while others became incredibly simple to implement with Spring and Java 8. However, the underlying principles never changed. We will take a Software Craftsmanship approach to those principles, always aiming for clean, maintainable and testable design.
Designing simple code is hard! Redesigning existing code is even harder but often imperative when facing legacy, or when you aim for a minimalistic emerging architecture. You should attend to this workshop if you want to:
- Design clean code that is simple, expressive, yet unit testable and flexible
- Become more proficient in the fundamental design concepts and principles
- Grow your skills to refactor existing/legacy code
- Learn more about Spring’s magic
By solving a series of exercises with Java 8 and Spring Framework, you will learn how to:
- Break down complex problems in simple patterns
- Avoid over-engineering and rigid code by keeping your design to a minimum
- Recognize patterns in existing code to understand its intention
- You will also discover many things you didn’t knew about Spring, even if this is not the main goal of the course.
Hundreds of developers have followed this training until now. For the last 4 years, split in 2 sessions, a simplified version of this training is also part of the “OOP” (aka “Java”) 2nd year Faculty Course in the CS Department of Politehnica Bucharest. In short, this is the ‘most wanted’ (and most refined) topic from Victor’s training curricula.
What will you learn?
- Design Principles and Concepts:
- Beck’s Rules of Simple Design
- Singleton – a stateful, burdened life, vs other lifestyles
- Adapter – the anti-corruption layer of DIP
- Decorator and Proxy – the “magic” of Spring
- Facade and an approach to evolutionary architecture
- Observer and event-driven Spring components
- Iterator and Stream – as a concept
- Strategy and Chain of Responsability – an application of SRP
- Command and asynchronism
- Template Method and its death by….
- Passing-a-block – the best of functional programming
- Anti-Patterns and some workarounds
- Final test + awards
The course is a mix of slides, brainstorms and a lot of exercises distilled from real problems, implemented with Spring and Java 8.
Who is the trainer?
This workshop will be conducted by two trainers:
Victor Rentea is one of the top Independent Trainers in Romania, having trained by now 1300+ developers in 30+ companies. He is Lead Architect at IBM, where he practices TDD, Pair Programming, Clean Code and Refactoring every day. For the community, he organized the largest 3 Bucharest Java User Group meetups in history, and last year he founded the Bucharest Software Craftsmanship Community in which he runs free webinars about clean code, refactoring and TDD. Today, Victor is regularly called by companies of all sizes to help seed the Software Craftsmanship ideology and eXtreme Programming practices into their technical culture. As a speaker, Victor is now regularly invited at the top international conferences: his live-coding sessions are insane, lightning-fast but well crafted, full of enthusiasm, deep insights and take-away tips. To learn more about/from him, follow his daily thoughts on LinkedIN, Facebook or Twitter, or check out http://victorrentea.ro.
Who is it for?
Enthusiast developers that have:
- At least several years of experience with Java
- Prior contact with Spring Framework is recommended, but not required
- Basic understanding of the Java 8 lambdas and streams (nice to have)
- Prior contact with Design Patterns would help skipping over the basics
A personal laptop with your favorite IDE, JDK 8+, working Maven (connected to central) and Git. You will be asked to clone a repository several days before the workshop.
Independent Technical Trainer + Architect @ IBM