Speaker Details

Victor Rentea

Independent + IBM

Victor is a Java Champion, and one of the top Technical Trainers in Bucharest, having trained by now more than 1.5K developers in 30+ companies throughout Europe. He is Lead Architect at IBM, practicing Pair Programming and Refactoring every day. Victor regularly speaks at top international conferences: his live-coding sessions are insane, lightning-fast but well crafted, full of enthusiasm, deep insights and take-away tips. Every month, Victor holds a community meetup, in any city he travels for classes. In Bucharest, after organizing the largest 4 JUG meetups in history, Victor started the Bucharest Software Craftsmanship Community in which he runs regularly free coding webinars (for now, spoken in Romanian). His personal commitment is to seed passion for writing clean, professional code. You can find Victor on Twitter (@victorrentea), LinkedIN or Facebook, or check out https://victorrentea.ro.

Unit Testing like a Pro - Towards a Testable Design

Conference
Methodology & Culture

Focusing on the creative work without being terrified of breaking the existing behavior can make software development very addictive! Good automated tests can buy you that! However, if your tests are not maintainable they may end up slowing you down and causing you painful headaches, compilation errors and spurious failures. To avoid that, your unit tests should be significant; expressive; clean; DRY; non-overlapping; and blazing fast. Writing good tests becomes the toughest challenge for any developer, no matter how battle-hardened: you need to balance risk with test maintenance costs, while looking out for test design smells that call for [risky] refactoring to drive your design towards a set of key principles (included:). Principles that will end up shaping the way you craft the Production code itself. Because in the end, a good, clean design is more important than coverage%. But testing gives you the best feedback to get there. Grab a black coffee and join this snippet from Victor’s Pro Unit Testing #training, to learn about testing priorities, buggy tests, the shared @Before, Mocks vs Stubs and how to reduce them by "purifying" your logic, testing Legacy Code and refactoring @Spy-es out. All of that in an entertaining, dynamic and memorable session.

Scheduled on Wednesday from 14:00 to 14:50 in Room 5

Slides
Design Principles
Unit Testing
Refactoring
Training

Evolving a Pragmatic, Clean Architecture - A Craftsman's Guide

Conference
Architecture

Are you in a mood for a brainstorm? Join this critical review of the major decisions taken in a typical enterprise application architecture and learn to balance pragmatism with your design goals. Find out how to do just-in-time design to keep as many use-cases as simple as possible. The core purpose of this presentation is to learn to strike a **balance between pragmatism and maintainability** in your design. Without continuous refactoring, a simple design will inevitably degenerate into a Big Ball of Mud, under the assault of the new features and bugfixes. On the other hand, the very highly-factored code can burden the take-off of the development and end up freezing the mindset in some rigid upfront design. The end goal of this talk is to challenge you to rethink critically the architecture of your systems and seek ways to simplify it to match your actual needs, with a pragmatic mindset. "Architecture is the art of postponing decisions", said Uncle Bob. This talk takes this idea further and explains an optimal mindset about designing enterprise applications: Evolving (Continuously Refactoring) a Pragmatic (Simple), Clean (aka Onion) Architecture, aiming to provide Developer Safety™️ and Comfort™️. It’s the philosophy that Victor distilled over the past 5 years, designing and implementing 9 applications as IBM Lead Architect, and delivering training and advises to many other companies. You’ll learn how to break data into pieces (Fit Entities, Value Objects, Data Transfer Objects), how to keep the logic simple (Facades, Domain Services, logic extraction patterns, Mappers, AOP), layering to enforce boundaries (keeping DTOs out of your logic, Dependency Inversion Principle), and many more, all in a dynamic, interactive and extremely entertaining session.

Scheduled on Wednesday from 12:00 to 12:50 in Room 9

Evolution
Simplicity
Design Principles
Refactoring
Architecture

Talks by tracksTalks by session typesList of SpeakersSchedule