Advanced Agile Programming Techniques
Gil Zilberfeld
We sometime forget, but Agile is primary about delivering working software. For working software we need to code, and this workshop is dedicated for the coding craftsman, and those who aspire to become one.
This is an opportunity to learn about different ways to code, experience them, and hopefully make use of them the day after when you’re back in the office.
We’ll explore different techniques: From Kent Beck’s simple design principles, going through a bunch of code smells, identifying and fixing them. We’ll talk about the Mikado method, and use it for refactoring, learn about preparing legacy code for testability, and even discuss the Transformation Priority Premise, a new concept that may alter the way we think about Test Driven Development.
Pick any language, as long as your IDE carries it. You can even switch languages to see what works for you better. This is deliberate practice at its best.
In this 1-day workshop, participants will get familiar with the technical skills and expertise that every team needs in order to truly be successful transitioning to Agile. Just changing how we manage our projects is not enough. To consistently deliver working software at high speeds, we need to improve the way we write code and why this workshop exists.
Learning outcomes:
Use refactoring patterns for making legacy code testable
Use techniques for refactor safely without tests
Write simple, expressive code
Identify and fix code smells
Use TDD in a more structured way
Introduction to Unit Testing in JavaScript
Gil Zilberfeld
Unit testing is known as one of the most effective software practices. Developers who write unit tests have less bugs, fix those bugs faster, and speed up development as a whole.
This course will introduce unit testing tools in the web and mobile space. Attendees will practice the needed techniques to start testing both new and existing code.
The course is intended for: front-end developers and team leaders.
Course goals
Following the workshop, attendees will be able to:
Use unit testing tools like Jasmin and Mocha
Write unit tests in Javascript
Refactor code to make it more testable
Mock different kinds dependencies
Include tests in automated builds
Course agenda
What are unit tests and how they compare to other types of tests
Pros and cons
Jasmine unit testing frameworks
Manual mocking
Sinon.js mocking framework
Using unit tests in automated builds
Unit testing best practices
Introduction to Test Driven Development
Introduction to Unit Testing in Java
Gil Zilberfeld
Unit testing is known as one of the most effective software practices. Developers who write unit tests have less bugs, fix those bugs faster, and speed up development as a whole.
This course will introduce unit testing tools in the Java space. Attendees will practice the needed techniques to start testing both new and existing code.
The course is intended for: Java developers and team leaders.
Course goals
Following the workshop, attendees will be able to:
Use unit testing tools like JUnit in Eclipse
Write unit tests in Java
Refactor code to make it more testable
Mock different kinds dependencies
Include tests in automated builds
Course agenda
What are unit tests and how they compare to other types of tests
Pros and cons
Java unit testing frameworks (JUnit and others)
Manual mocking
Java mocking frameworks (Mockito and PowerMockito)
Using unit tests in automated builds
Unit testing best practices
Introduction to Test Driven Development
Refactoring In Legacy Code
Gil Zilberfeld
Refactoring is a set of skills. We use refactoring on code and tests, to make sure we will be able to maintain our code and change it quickly the next time we need to change it. While it is easy to do with tests, it is harder (but even more essential) to do with legacy code.
In this course, we’ll try our hands in different techniques of refactoring. We’ll discuss naming methods, code extraction, practice refactoring before and after tests, and understand how to refactor legacy code to make it more testable. The objective is to learn the principles of simple design and apply them through refactoring for better code.
This is an medium level hands-on workshop. It is intended for developers with basic unit testing experience.
After this workshop you will be able to:
Make changes safely to existing complex code
Prepare your existing legacy code for unit testing
Refactor for better design with the aid of tests
Workshop outline:
Refactoring with tests – Code smells deodorant
Refactoring with comparison tools
Refactoring as preparation for tests
Target audience: This workshop is for developers with some unit testing experience who want to enhance their skills. Attendees need to bring a laptop with their favorite IDE in their favorite language (it doesn’t matter which one), and a testing framework.
Effective Unit Testing
Gil Zilberfeld
When we start looking into unit testing, we get the simple examples that work in an ideal world. When we start working on actual code, we bump into reality. While unit testing is not easy, it can be easier.
In this course, we’ll try our hands in different techniques of unit testing. We’ll discuss naming methods, practice refactoring and techniques of Test Driven Development that work in the real world. Although we think about unit testing as a “tool" thing, it is really a set of skills that we can continue to develop over years. In this workshop we will learn how we can identify and improve those skills.
This is an advanced hands-on workshop. It is intended for developers who already have basic unit testing experience.
Course goals
After this workshop you will be able to:
Understand and design your code according to the “Four Rules of Simple Design”
Prepare your existing legacy code for unit testing
Refactor for better design with the aid of tests
Identify and use patterns used in TDD
Use the “Transformation Priority Premise” in TDD
Workshop outline
Unit testing with real code
4 Rules of Simple Design
Refactoring with tests – Code smells deodorant
Refactoring as preparation for Tests
TDD Patterns
Transformation Priority Premise
Target audience: This workshop is for developers with some unit testing and/or TDD experience who want to enhance their skills. Attendees need to bring a laptop with their favorite IDE in their favorite language (it doesn’t matter which one), and
Introduction to Unit Testing and TDD in Embedded Software
Gil Zilberfeld
Unit testing is known as one of the most effective software practices. Developers who write unit tests have less bugs, fix those bugs faster, and speed up development as a whole. In embedded software, with limited resources, and complex tools, unit testing becomes even more important.
This course will introduce unit testing tools in the embedded C/C++ environment. Attendees will practice the needed techniques to start testing both new and existing code.
The course is intended for: C/C++ developers and team leaders.
Course goals
Following the workshop, attendees will be able to:
Use unit testing tools with existing dev tools
Write unit tests in C/C++
Refactor code to make it more testable
Mock different kinds dependencies
Include tests in automated builds
Course agenda
What are unit tests and how they compare to other types of tests
Pros and cons
C/C++ unit testing frameworks (GoogleTest and others)
Manual mocking
C/C++ mocking frameworks (FakeIt and others)
Using unit tests in automated builds
Unit testing in an embedded environment best practices
Introduction to Test Driven Development (TDD)
Unit tests spring cleaning
Gil Zilberfeld
If you’ve been doing unit testing for a while, you’re probably happy. And you’re probability facing a new set of problems.
Unit testing maintenance is a headache.
But more than that – we have all kind of tests: unit, integration, acceptance, all jumbled up together. We throw them all into one giant suite and expect quick feedback.
It’s time to take stock and take action. We’ll take a look how to overhaul our tests, depending on metrics we can track and analyze. We’ll do some risk analysis to see what to keep, and might even take some extreme measures. Maybe even decide to remove tests (God help us!!!) from our suite. We’ll optimize test runs, look at test organization approaches, continuous integration cycle optimization methods and make sure we get feedback as quickly as possible.
Having a suite of tests is just the beginning. Having a great suite of tests is much more effective.
Introduction to Unit Testing in .Net
Gil Zilberfeld
Unit testing is known as one of the most effective software practices. Developers who write unit tests have less bugs, fix those bugs faster, and speed up development as a whole.
This course will introduce unit testing tools in the .Net space. Attendees will practice the needed techniques to start testing both new and existing code.
The course is intended for: C# developers and team leaders.
Course goals
Following the workshop, attendees will be able to:
Use unit testing tools in Visual Studio
Write unit tests in C#
Refactor code to make it more testable
Mock different kinds dependencies
Include tests in automated builds
Course agenda
What are unit tests and how they compare to other types of tests
Pros and cons
.Net unit testing frameworks (MSTest and others)
Manual mocking
.Net mocking frameworks (FakeItEasy and others)
Using unit tests in automated builds
Unit testing best practices
Introduction to Test Driven Development
Tips for Successful Pair Programming
Gil Zilberfeld
Pair programming is one of Extreme Programming basic rules. Even if you haven’t done pair-programming full time, you’ve probably done it unaware, working with a teammate on fixing a tough bug.
What happens when you start doing it fulltime? The benefits are many, but the process is not as simple as it looks. Lots of questions come up:
Who’s coding when? What happens when the pair is not matched in terms of experience or knowledge? Or when your partner speeds up and leaves you behind? How do we match pairs? Should we even do that?
It seems there are both social aspects, as well as technical aspects to consider.
In this talk we’re going to discuss what makes pairing effective, including when to do it, which tasks should we pair on, optimizing pairing sessions and what skills we should improve.
Pair programming is one of the most effective ways I know to get rid of bugs. Let’s learn how to make it work for us.
Real life TDD: Building a Spaceship
Gil Zilberfeld
I bet you've had enough of calculator examples. Let's do something important. Something that will change the world. We're going to TDD a... Spaceship!
In this tutorial we're going to:
• Collect requirements
• Analyze the requirements as we go
• Discuss design options
• Evaluate API
• Have fun
• Build a real (virtual) spaceship using test driven development.
If you ever thought of building a spaceship, this is your chance to do it the right way!
Attendees work in pairs, and need an IDE and a test framework. Language is irrelevant, along as the pairs can work together. We work in cycles, each cycle concentrates on a certain technique: naming, ping-pong, etc. Then we review and continue to the next round.