We offer 3 one day long workshops on 29nd of January. These will start at 9:30 am and work untill 4:30 pm with an hour break for a lunch.

The workshops are paid additionaly. The price includes lunch or pizza.

The workshops will be delivered in Adam's Conference Center:

Adam's Conference Center (ACC)
Matejki 62 Street
60-771 Poznan

Here you can find how to get there.

Crafting Code

Workshop mastered by: Sandro Mancuso

Software Craftsman and co-founder of Codurance.
Read more >

Date: 29th January

Price: 649 PLN (160 EUR) + 23% VAT

You will need to bring your laptop!


This course is designed to help developers write well-crafted code—code that is clean, testable, maintainable, and an expression of the business domain. The course is entirely hands-on, designed to teach developers practical techniques they can immediately apply to real-world projects.

Why attend?

Software Craftsmanship is at the heart of this course. Throughout, you will learn about the Software Craftsmanship attitude to development and how to apply it to your workplace.

Writing Clean Code is difficult. Cleaning existing code, even more so. You should attend if you want to:

  • Write clean code that is easy to understand and maintain
  • Become more proficient in Test-Driven Development (TDD): using tests to design and build your code base
  • Focus your tests and production code according to business requirements using Outside-In TDD (a.k.a. the London School of TDD)
  • Clean code necessitates good design. In the process of driving your code through tests, you will learn how to:

  • Understand design principles that lead to clean code
  • Avoid over-engineering and large rewrites by incrementally evolving your design using tests
  • Once you have an understanding of the principles at work, we will apply them to Legacy Code to help you gain confidence in improving legacy projects through testing, refactoring and redesigning.
  • Content

  • TDD lifecycle and the Outside-In style of TDD
  • Writing unit tests that express intent, not implementation
  • Using unit tests as a tool to drive good design
  • Expressive code
  • Testing and refactoring Legacy Code
  • The course is fully hands-on and developers will be writing a lot of code.
  • Audience

    Software developers that:

  • are familiar with at least one Object-Oriented language
  • are able to understand Java or C#
  • Legacy code exercise will be done in one of the following languages: Java, C#, PHP, Scala, or C++
  • can write and execute unit tests using a framework (such as JUnit, NUnit, etc.)
  • have a basic understanding of mock objects
  • Prerequisites

    Developers must:

  • bring their own laptops
  • have a development environment consisting of:
    • their favourite Object-Oriented language
    • a unit test framework
    • a mocking library
  • be able to create projects, build source code and run test cases in their development environment
  • In addition, a distributed version-control system such as Git is desirable.

    Introduction to BDD using JS

    Workshop mastered by: Enrique Amodeo

    Senior Software Engineer at eBay.
    Read more >

    Date: 29th January

    Price: 349 PLN (85 EUR) + 23% VAT

    You will need to bring your laptop!


    This workshop will give you an opportunity to practice BDD using JS. We will use some JS modern tools for testing, and how to organise the code to make it easily testable. But we will focus on how to write the tests that really matter, instead of the more widespread approach of one test per class.

    Why attend?

    BDD is a widely misunderstood technique. There are a lot of books and blog posts about it, but the best way to learn it is through practice. Specially hard to grasp is the ability to write the tests that really matter. In this workshop you will get a first exposure to this.

    You should attend if you want to:

  • Learn the test first cycle: red/green/refactor
  • Write test code that is easy to understand and maintain
  • Write test code that is directly related to business requirements
  • How to architecture your system to make it easily testable
  • Content

    TDD lifecycle and the Outside-In style of TDD Writing unit tests that express intent, not implementation

    The workshop is fully hands-on and developers will be writing a lot of code.


    Software developers that have basic/medium JavaScript knowledge and want to start doing testing for real. Knowing how to install NodeJS and basic usage of NPM is good to have, but if you don't know how to, I will help you!


    Developers must bring their own laptops with a development environment consisting of NodeJS and your favourite JavaScript IDE/Editor. We will install during the workshop Mocha, Chai, and more.

    Legacy code

    Workshop mastered by: Krzysztof Jelski

    Software Craftsman & Agile Coach working at Pragmatists.

    Date: 29th January

    Price: 549 PLN (130 EUR) + 23% VAT

    You will need to bring your laptop!


    In this workshop you’ll learn techniques that allow you to work safely with code without tests. You’ll work a lot with code, starting with short, focused exercises and then moving to a much more realistic, near real-life application example.

    Why Attend?

    You’ve just become a fan of TDD but your codebase has no tests. Now what? Writing a test for existing behaviours seems to be a daunting task. Changing something without a test seems too risky. Writing a test for new features should be easy, but it’s not. But have no fear, you can tackle your not-so-clean codebase with a set of well-established techniques for working with legacy code.

    The techniques come from the great book “Working Effectively with Legacy Code” by Michael Feathers.


    The workshop will be split into two parts.

    1. Dependency Breaking Techniques
    The first part will offer a bit of theory as well as small, focused exercises to practice Dependency Breaking Techniques. What are those? Refactorings which make it possible to write tests for hard-to-test code.

    2. Legacy Code exercise
    In the second part of the training you’ll be able to try your skills against a near real-life code. You’ll be practicing the Legacy Code Change Algorithm:

  • Identify change points.
  • Find best possible test points.
  • Break dependencies, if needed.
  • Write tests (for both old and new features),
  • Make changes and refactor.
  • Iterating through those steps, you’ll make changes to an existing, non-trivial application in a safe manner.


    Participants should feel comfortable working with Java code. Experience with writing tests using a testing framework like JUnit is also assumed.


    Please bring your own laptops with your favourite Java IDE installed. JDK 8 is recommended.