Instructor: Gil Broza
Gil Broza helps software organizations who want to adopt Agile, or their current use of it isn't delivering on its promise. He guides them in implementing a reliable, sustainable methodology so they truly delight their customers and make a positive impact. He is an “all-rounder”, working at all organizational levels and coaching people in technical, managerial and leadership behaviours.
Gil's book, “The Human Side of Agile: How to Help Your Team Deliver”, is the definitive practical guide to leading Agile teams to outstanding performance. Gil has been a regular contributor and coaching stage producer for the Agile series of conferences, a sought-after speaker for other industry events and groups, and host of numerous public webinars about Agility. Get a taste of Gil's approach here.
Gil has an M.Sc. in Computational Linguistics and a B.Sc. in Computer Science and Mathematics from the Hebrew University of Jerusalem, Israel. He is a certified NLP Master Practitioner and has studied organizational behaviour and development extensively. He has written several practical papers for conferences and trade magazines, including the prestigious Cutter IT Journal. Gil lives in Toronto.
What Others Are Saying...
- “Thank you for teaching the Agile Engineering Course. I'm glad I took it and it certainly opened my mind to the “smells” of bad code and how to detect them... Your course gave just enough information and motivation to get started. You taught by convincing us on why Agile/XP and TDD is important with real world examples, instead of lecturing from a book.” — Senthuran Sivananthan, Architect, Architech Solutions
- “I engaged Gil to assess and coach three of my Agile development teams, ranging from novice to experienced. Gil's rational approach and wealth of experience made him effective when dealing with Agile sceptics and enthusiasts alike. His recommendations were pragmatic yet fresh, and resulted in meaningful team performance improvements in each case. In particular, the teams have all observed a noticeable up-tick in collaboration. I'd recommend Gil's services to anyone interested in adopting or improving agile or lean practices.” — Darryl Minard, Senior manager, Canada Pension Plan Investment Board (CPPIB)
- “Gil is able to get people to try new things, even if they are a little uneasy about moving in the new direction... People know that they'll have an out if they don't like the results and that Gil will support them in trying the new approach.” — Bob Fischer, Vice President, Fidelity Investments
- “Gil is an engaging educator, who is able to convey his point clearly and succinctly.” — Dmitri Sotnikov, developer, University Health Network, Toronto
- “I attended Gil's Agile training recently and was very impressed with the expertise and experience. The training not only covered the theory impeccably, but the practical hands-on work that followed allowed the participants to ensure that what was taught could be tried and tested.” — Bharathi B., developer, VFA
- “Gil provided a great training on Test Driven Development (TDD) in my work place. The course was very helpful to understand the TDD concepts, and it was extremely well organized. The course started from basics and in three days we get to see and practice advanced topics in TDD. The lab assignments that we did during the training were well designed to understand and practice TDD.” — Ashkan Aazami, Software Engineer, Empathica
- “Of all the presenters so far, you've been the most realistic.” — Bill O. commenting on “Secrets of High-Performance Agile Implementations” at SD Best Practices, Boston, 2008
- “Gil has been instrumental in raising the bar on the quality of the deliverables of our agile team. The code refactoring exercises, on real/live code, doubled as delivery of new features and as significant increase on the developers' skills.” — Horia Balog, senior architect, Architech
- “Even after almost a year our developers continue to make reference to various things Gil had said during the training, which I think is an excellent tribute to his effectiveness. His experience enabled him to handle any question we had, and he was able to quickly show us how to apply many of the training topics (code smells, microtesting, refactoring) to our own code.” — David Day, Manager, Cincinnati
The Programming Experience
Writing new code is one of the joys of programming. Modifying existing code is often one of the nightmares of programming. Unfortunately, you will spend more time reading and modifying existing code than writing new code.
Modifying existing code often results in Whac-A-Mole Programming — you make a change in one part of the code, and a problem crops up in another place. You fix that problem and two more pop up. You quickly find yourself trapped in debug hell. Work in an Agile environment and now you feel the regular pressure to have shippable code every two weeks.
There is a better way: a sane approach to dealing with both new code and legacy code. A framework for bringing order to code chaos, for making changes to existing code that are actually improvements. And this course provides a powerful approach to developing and modifying code.
If you've been programming professionally even just a couple of years, you've likely noticed that:
- Fixing bugs can take anywhere from a few minutes to a few days - or even longer! - and is even less fun in code written by other people.
- The larger a feature gets, the longer it takes to enhance or maintain (and the scarier it gets to do so).
- However elegant, clear or clever your code appeared when you first wrote it, when you revisit it a year later you shudder (or scratch your head).
- Code-level documentation, even when it exists, somehow never gives you the information or confidence you need.
- Even “tested” code breaks where you least expect it to.
Only a decade ago this was our profession's accepted reality. But the rules have changed.
In this XP/Agile Engineering course (previously known as “Programming Without Fear”) you will learn reliable, sustainable and enjoyable software development practices which you can immediately put to use. These techniques, first popularized in Extreme Programming (XP), have been proven, refined and extended for more than a decade. By using them you will produce working code faster, increase its quality, and reduce technical debt — the demon that snarls later development.
And if you happen to be working with an Agile team, perhaps using Scrum, you've probably noticed that traditional software development tactics don't work as well anymore. Big Design Up Front, detailed design documents, manual test plan execution, code freezes and other plan-driven approaches just don't achieve great results in a fast-paced, iterative environment. In fact, an Agile project management framework without suitable technical discipline is a great way to guarantee failure. The techniques you'll learn in this course are just the ones you need.
After this course you will be able to:
- Develop simple, clear, tested code faster than you ever did
- Practise modern techniques such as test-driven development and refactoring
- Evolve object-oriented software with tests' guidance
- Unit-test the tough cases
- ... And have the skills needed to stop dreading legacy code!
Code smells. Just as programmers can leverage design patterns and good Object Oriented (OO) practice to produce excellent code, they can know what sort of code to avoid. This knowledge has been catalogued and codified as a few dozen anti-patterns called “code smells”. Methods so long as to require scrolling, classes that have too many disparate responsibilities, and primitives that carry meanings are but three examples of code smells.
We will study more than a dozen common smells that occur within methods or classes. By studying these anti-patterns you'll get a better feel for clean code, and develop your “nose” for finding low-level design defects so that you can more easily remove them from your code. This is crucial, because code smells often hide bugs.
Refactoring. Even if the code you write today is 100% correct, you will still have to touch it in a month or a year: Extract some reusable pieces, reorganize it for clarity, replace some logic with calls to shared functionality, simplify it, etc. Preserving behavior while improving implementation and design is called “refactoring”, and it is quite distinct from “rewriting”. In this course we will study two levels of refactoring:
- Low-level refactorings, such as Extract Method and Compose Method. These refactorings alter a few lines of code often in the context of one or two methods. They are quite mechanical in nature, to the extent that modern tools like Eclipse have automated them almost entirely.
- High-level strategies, such as Gradual Cutover and Parallel Change, which combine several low-level refactorings to make refactoring safe and reliable. If you've ever had to make medium- to large design changes, perhaps some of your unit tests began to fail, or the code didn't even compile for a few hours; these strategies will help you avoid this scary zone.
Microtesting. Commonly called “unit testing”, this is the art and science of writing focused, quick, extremely low-level tests against your code to prove that it does what you think it ought to do. By writing many of these microtests against your code, you will be able to develop it predictably, introduce far fewer defects, and spend a lot less time debugging now and later.
Many programmers automate their unit tests these days, and often fall into the trap of the brittle tests — tests that are difficult to change and sensitive to production code changes. You will learn how to write proper, robust, reliable microtests and how to keep them that way.
Test-driven development (TDD). The TDD process is the best thing you can do when writing new code, be it small or large. TDD combines microtesting, small code increments or changes and merciless refactoring to have you write great code without fear. Remember when you would write a few dozen (or a hundred?) lines of code, start testing them, then fix the bugs you found? And remember that it was impossible to estimate (guess) how long finding and fixing the bugs would take? That is a thing of the past with TDD.
Having studied basic application of code smells, refactoring, microtesting and TDD, we will work on “big code problems”:
Dependencies. Most objects in most systems don't work in isolation; they depend on other objects. Sometimes these dependencies (a.k.a. collaborations, interactions) make testing difficult, unreliable, slow, or ineffectual. Still, that's no reason to avoid microtesting and just do slow end-to-end testing! You'll learn how to ensure the speed and fidelity of your microtests when dependencies are present. You will study techniques like faking, stubbing, mocking, and dependency injection. You will practice keeping your tests sharp while testing the contents and process of the interactions themselves.
Test smells. Just as production code manifests patterns of ill-design (code smells), so do microtests. As more tests and production code get written, tests become more brittle, erratic, slow, harder to follow or reuse, and rife with duplication. We will study known patterns in which this trouble unfolds, and discuss ways to nip it in the bud early and often (hint: this has to do with refactoring...)
Most course attendees work in a Scrum/Agile/Lean environment, with a team that delivers valuable increments of working software on a regular basis. However, many Agile practitioners have trouble bridging the gap between the large feature requests in their queue and the bottom-up, one-small-step-at-a-time TDD approach. They also feel that along the way, they must sacrifice design and architecture. This course is structured for a clear demonstration of how exactly to integrate the project management framework with agile technical discipline for evolving solid software.
You will move from hacking at the code — perhaps creating more problems than you solve — to code craftsmanship.
Previous participants have said:
“Gil did a much better job of explaining the context/purpose of these practices than other presenters I've seen.”
“I can honestly say this was one of the best seminars I've ever been to.”
“The instructor-student engagement was great.”
“Pleasant flow, good humour, fun exercises, good pace.”
“Gil made complexity accessible! Extremely well thought out.”
“The course was very helpful to understand the TDD concepts, and it was extremely well organized.”
“Everything we learned is immediately implementable in the real world.”
Immersive Experience — No Boring Lecture
You must have been around software enough to know the two best ways to learn such skills: watch the expert, and practise on your own.
You will spend at least 50% of the course's time in labs practising your new skills.
- You'll work in frequently-changing pairs, which will allow you to test your understanding and learn additional insights. (Almost unanimously, attendees report that this pairing model is delightful and a great learning enhancer.)
- Each lab is either a small task or a series of graded small tasks.
- Each lab is accompanied by the instructor's solution.
You will also watch video demonstrations of the instructor applying some of the harder techniques.
The rest of the time, you will be engaged in an interactive presentation with the instructor.
Curious? Watch one of the demonstration videos (opens in a new tab).
You'll do the labs and watch the demonstration videos in the language of your choice: Java or C#. However, this course is all about principles, mindset, and technique — not language or tool specifics. The techniques and strategies you'll learn are fully and immediately transferable across modern programming languages and technologies; we often have attendees who "speak" PHP, GWT, Python, or VB.NET, for instance. Even if your native tongue is not Java/C# but you're comfortable with OO, this course would be perfect for you.
Previous participants said:
“The labs were relevant and engaging. Real-world examples helped to put things in context.”
“Good labs. Small enough but not too small.”
“Outstanding exercises. Gil was extremely clear.”
“Good mix of theory and practice.”
“I took a 1-day course in TDD a little over a month ago. I got more out of this seminar even without knowing Eclipse & being rusty at Java.”
“The lab assignments that we did during the training were well designed to understand and practice TDD.”
If The Timing's Not Right...
Would you like to be the first to know when new offerings are available?
All you need to do is sign up for our bi-weekly e-zine, the 3P Vantage Point, where such announcements are first made.
Just enter your first name and email in the box below. PRIVACY ASSURED!
You will also start receiving Something Happened on the Way to Agile, Gil's free, 20-day mini-program to help you overcome common Agile challenges and concerns.