Opportunity to grow

In 2022, in addition to the work we do for our clients, we put our heads together and organized events and activities that would help us further develop our skills and knowledge, while providing a healthy break from our daily tasks. What follows is a brief account of what we planned, what worked and what didn’t.

Book Santa

We started the new year with gifts. Everyone could order a book, an actual physical book made of paper and ink, the only condition was that it be “at least a little work-related”. The idea was well received and orders soon poured in. The logistics involved in collecting titles from 130 people, ordering and then sending them to those who work more often remotely proved something of a challenge, but somehow we managed. Only one book from the UK got irretrievably stuck in customs (thanks, Brexit!). I don’t know how many books were read – since they were gifts, it didn’t seem appropriate to ask! – but I do know that one of them is currently being used as a monitor stand. An unexpectedly fascinating side effect of the scheme was being able to take a look at the freely available excel sheet and see who had ordered what and to learn about books you’d previously been unaware of.


We meet once a month on a Friday to hear three people from the company, usually developers, give short presentations. Ensuring that every month there are enough volunteers willing to talk about something technical or somehow related to our work is no mean feat. Persuading, encouraging, twisting the arms of busy colleagues is a major challenge for the organizers of these talks. Occasionally, these talks cover less technical areas and we get the chance to learn about advantages of giving and receiving feedback, money saving and how to become a conference speaker. The purpose of Flashtalks is to both share knowledge and create a space where presentation skills can be practiced and honed in front of a larger audience. In 2022 there were 29 speakers (seven of whom spoke twice) and 36 presentations altogether. Topics ranged from “How to monitor applications after deployment” to “Will Niagara Files work on the Mississippi” and “DIY simple lab power supply”. Both novice developers as well as senior conference veterans share their wisdom. One of the great things about Flashtalks is the post-talk questionnaire, which always provides us with valuable feedback on what went well and what could be done better. Each Flashtalk ends with a quiz, which introduces an element of gamification and prevents Flashtalks from becoming merely a chance to take a break from work.

One of the aims of the Flashki is to create new conference speakers. This year Monika Fus made her debut at Confitura, an event very much close to our hearts, where she spoke about “L10n, i18n and t9n in the JVM world”. Other speakers included Piotr Fus with his presentation “How to get started with metrics”, Maciek Próchniak with “Well, it’s time to synchronize watches” and Dominik Przybysz with “OOP Revisited”. The whole team traveled around Poland and beyond with their presentations. Check them out here: https://touk.pl/talks/2022. While we had hoped there would be more newcomers in 2022, we are confident that 2023 will see a greater number of conference debuts.


TouK Dojo is a more hands-on learning initiative that one of the developers came up with this year. We hold technical workshops for each other and meetings where we solve problems, often algorithmic. It’s a good opportunity to bounce ideas off each other about how to do things, try out tools, ask questions and work on real examples. Meetings usually take place once a week, live and online.


In April, as a grassroots initiative, a few of us set a goal to post monthly on our company blog. We wanted to restore it to its former glory, or perhaps just revive it after the drought years of the pandemic. We almost succeeded, with our combined efforts resulting in six posts about hackathons, a summary of the first post-pandemic Confitura, and of course some technical posts. We are now thinking about how to take the initiative further. It seems that the valuable content we could share is there, but we need to find the time and a way to overcome writer’s block.


Last year we organized a couple of hackathons: one in the spring and one in the autumn. We had initially considered having four in the space of a year, but that turned out to be a bit too ambitious, given the amount of work we do for our clients and the number of ideas to hack. The general framework developed in battle is: two days in our office, any project, any team composition, pizza and snacks for all. You can read detailed descriptions of what we achieved here: https://touk.pl/blog/2022/05/12/touk-hackathon-toukathon-april-2022/ and https://touk.pl/blog/2022/11/28/toukathon-october-2022/. In spring sixteen people coded together, in autumn eight.


It has always been possible for any employee to order books for our shared library. Perhaps because of the number of books gifted at the start of the year, the number of books ordered during the year was a little smaller than normal. Still, our library has now been enriched with:

  • Diagnosing and Changing Organizational Culture: Based on the Competing Values Framework, Kim S. Cameron, Robert E. Quinn
  • The Enterprise Big Data Lake, Alex Gorelik
  • The Java Module System, Nicolai Parlog
  • Bulletproof TLS and PKI 2ed, Ivan Ristić
  • Job crafting nowa metoda budowania zaangażowania i poczucia sensu w pracy, Malwina Puchalska-Kamińska, Agnieszka Łądka- Barańska
  • Functional programming in Scala second edition, Paul Chiusano, Runar Bjarnason
  • Functional Design and Architecture v7, Alexander Granin
  • Functional Event-Driven Architecture, Gabriel Volpe
  • Code, Charles Petzold

Since January is time for resolutions, here are ours. This year we want to continue the Flashki (the first has already taken place on 20 January), we will confidently hack together, and we are already planning a calendar of speeches at conferences.

You May Also Like

33rd Degree day 2 review

Second day of 33rd had no keynotes, and thus was even more intense. A good conference is a conference, where every hour you have a hard dilemma, because there are just too many interesting presentations to see. 33rd was definitely such a conference, and the seconds day really shined.

There were two workshops going on through the day, one about JEE6 and another about parallel programming in Java. I was considering both, but decided to go for presentations instead. Being on the Spring side of the force, I know just as much JEE as I need, and with fantastic GPars (which has Fork/Join, actors, STM , and much more), I won't need to go back to Java concurrency for a while.

GEB - Very Groovy browser automation

Luke Daley works for Gradleware, and apart from being cheerful Australian, he's a commiter to Grails, Spock and a guy behind Geb, a  browser automation lib using WebDriver, similar to Selenium a bit (though without IDE and other features).

I have to admit, there was a time where I really hated Selenium. It just felt so wrong to be writing tests that way, slow, unproductive and against the beauty of TDD. For years I've been treating frontend as a completely different animal. Uncle Bob once said at a Ruby conference: "I'll tell you what my solution to frontend tests is: I just don't". But then, you can only go so far with complex GUIs without tests, and once I've started working with Wicket and its test framework, my perspective changed. If Wicked has one thing done right, it's the frontend testing framework. Sure tests are slow, on par with integration tests, but it is way better than anything where the browser has to start up front, and I could finally do TDD with it.

Working with Grails lately, I was more than eager to learn a proper way to do these kind of tests with Groovy.

GEB looks great. You build your own API for every page you have, using CSS selectors, very similar to jQuery, and then write your tests using your own DSL. Sounds a bit complicated, but assuming you are not doing simple HTML pages, this is probably the way to go fast. I'd have to verify that on a project though, since with frontend, too many things look good on paper and than fall out in code.

The presentation was great, Luke managed to answer all the questions and get people interested. On a side note, WebDriver may become a W3C standard soon, which would really easy browser manipulation for us. Apart from thing I expected Geb to have, there are some nice surprises like working with remote browsers (e.g. IE on remote machine), dumping HTML at the end of the test and even making screenshots (assuming you are not working with headless browser).

Micro services - Java, the Unix Way

James Lewis works for ThoughtWorks and gave a presentation, for which alone it was worth to go to Krakow. No, seriously, that was a gem I really didn't see coming. Let me explain what it was about and then why it was such a mind-opener.
ThoughtWorks had a client, a big investment bank, lots of cash, lots of requirements. They spent five weeks getting the analysis done on the highest possible level, without getting into details yet (JEDI: just enough design initially). The numbers were clear: it was enormous, it will take them forever to finish, and what's worse, requirements were contradictory. The system had to have all three guarantees of the CAP theorem, a thing which is PROVED to be impossible.
So how do you deal with such a request? Being ThoughtWorks you probably never say "we can't", and having an investment bank for a client, you already smell the mountains of freshly printed money. This isn't something you don't want to try, it's just scary and challenging as much as it gets.
And then, looking at the requirements and drawing initial architecture, they've reflected, that there is a way to see the light in this darkness, and not to end up with one, monstrous application, which would be hard to finish and impossible to maintain. They have analyzed flows of data, and came up with an idea.
What if we create several applications, each so small, that you can literally "fit it in your head", each communicating with a simple web protocol (Atom), each doing one thing and one thing only, each with it's own simple embedded web server, each working on it's own port, and finding out other services through some location mechanism. What if we don't treat the web as an external environment for our application, but instead build the system as if it was inside the web, with the advantages of all the web solutions, like proxies, caches, just adding a small queue before each service, to be able to turn it off and on, without loosing anything. And we could even use a different technology, with different pair of CAP guarantees, for each of those services/applications.
Now let me tell you why it's so important for me.
If you read this blog, you may have noticed the subtitle "fighting chaos in the Dark Age of Technology". It's there, because for my whole IT life I've been pursuing one goal: to be able to build things, that would be easy to maintain. Programming is a pure pleasure, and as long as you stay near the "hello world" kind of complexity, you have nothing but fun. If we ever feel burned out, demotivated or puzzled, it's when our systems grow so much, that we can no longer understand what's going on. We lose control. And from that point, it's usually just a way downward, towards complete chaos and pain.
All the architecture, all the ideas, practices and patterns, are there for just this reason - to move the border of complexity further, to make the size of "possible to fit in your head" larger. To postpone going into chaos. To bring order and understanding into our systems.
And that really works. With TDD, DDD, CQRS I can build things which are larger in terms of features, and simpler in terms of complexity. After discovering and understanding the methods (XP, Scrum/Kanbad) my next mental shift came with Domain Driven Design. I've learned the building block, the ideas and the main concept of Bounded Contexts. And that you can and should use a different architecture/tools for each of them, simplifying the code with the usage patterns of that specific context in your ming.
That has changed a lot in my life. No longer I have to choose one database, one language and one architecture for the whole application. I can divide and conquer, choose what I want to sacrifice and what advantages I want here, in this specific place of my app, not worrying about other places where it won't fit.
But there is one problem in here: the limit of technologies I'm using, to keep the system simple, and not require omnipotence to be able to maintain, to fix bugs or implement Change Requests.
And here is the accidental solution, ThoughtWorks' micro services bring: if you system is build of the web, of small services that do one thing only, and communicate through simple protocol (like Atom), there is little code to understand, and in case of bugs or Change Requests, you can just tear down one of the services. and build it anew.
James called that "Small enough to throw them away. Rewrite over maintain". Now, isn't that a brilliant idea? Say you have a system like that, build over seven years ago, and you've got a big bag of new requests from your client. Instead of re-learning old technologies, or paying extra effort to try to bring them up-to-date (which is often simply impossible), you decide which services you are going to rewrite using the best tools of your times, and you do it, never having to dig into the original code, except for specification tests.
Too good to be true? Well, there are caveats. First, you need DevOps in your teams, to get the benefits of the web inside your system, and to build in the we as opposite to against it. Second, integration can be tricky. Third, there is not enough of experience with this architecture, to make it safe. Unless... unless you realize, that UNIX was build this way, with small tools and pipes.
That, perhaps. is the best recommendation possible.

Concurrency without Pain in Pure Java

Throughout the whole conference, Grzegorz Duda had a publicly accessible wall, with sticky notes and two sides: what's bad and what's good. One of the note on the "bad" side was saying: "Sławek Sobótka and Paweł Lipiński at the same time? WTF?". 
I had the same thought. I wanted to see both. I was luckier though, since I'm pretty sure I'll yet be able too see their presentations this year, as 33rd is the first conference in a long run of conferences planned for 2012. Not being able to decide which one to see, I've decided to go for Venkat Subramaniam and his talk about concurrency. Unless we are lucky at 4Developers, we probably won't see Venkat again this year.
Unfortunately for me, the talk ("show" seems like a more proper word), was very basic, and while very entertaining, not deep enough for me. Venkat used Closure STM to show how bad concurrency is in pure Java, and how easy it is with STM. What can I say, it's been repeated so often, it's kind of obvious by now.
Venkat didn't have enough time to show the Actor model in Java. That's sad, as the further his talk, the more interesting it was. Perhaps there should be a few 90min sessions next year?

Smarter Testing with Spock

After the lunch, I had a chance to go for Sławek Sobótka again, but this time I've decided to listen to one of the commiters of Spock, the best thing in testing world since Mockito. 
Not really convinced? Gradle is using Spock (not surprisingly), Spring is starting to use Spock. I've had some experience with Spock, and it was fabulous. We even had a Spock workshop at TouK, lately. I wanted to see what Luke Daley can teach me in an hour. 
That was a time well spent. Apart from things I knew already, Luke explained how to share state between tests (@Shared), how to verify exceptions (thrown()), keep old values of variables (old()), how to parametrize description with @Unroll and #parameterName, how to set up data from db or whatever with <<, and a bit more advanced trick with mocking mechanism. Stubbing with closures was especially interesting.

What's new in Groovy 2.0?

Guillaume Laforge is the project lead of Groovy and his presentation was the opposite to what we could see earlier about next versions of Java. Most visible changes were already done in 1.8, with all the AST transformations, and Guillaume spent some time re-introducing them, but then he moved to 2.0, and here apart from multicatch in "throw", the major thing is static compilation and type checking.
We are in the days, were the performance difference between Java and Groovy falls to a mere 20%.  That's really little compared to where it all started from (orders of magnitude). That's cool. Also, after reading some posts and successful stories about Groovy++ use, I'd really like to try static compilation with this language
Someone from the audience asked a good question. Why not use Groovy++ as the base for static compilation instead. It turned out that Groovy++ author was also there. The main reason Guillaume gave, were small differences in how they want to handle internal things. If static compilation works fine with 2.0, Groovy++ may soon die, I guess.

Scala for the Intrigued

For the last talk this day, I've chosen a bit of Scala, by Venkat Subramaniam. That was unfortunately a completely basic introduction, and after spending 15 minutes listening about differences between var and val, I've left to get prepared to the BOF session, which I had with Maciek Próchniak.

BOF: Beautiful failures

I'm not in the position to review my own talk, and conclude whether it's failure was beautiful or not, but there is one things I've learned from it.
Never, under none circumstances, never drink five coffees the day you give a talk. To keep my mind active without being overwhelmed by all the interesting knowledge, I drank those five coffees, and to my surprise, when the talk started, the adrenaline shot brought me over the level, where you loose your breath, your pulse, and you start to loose control over your own voice. Not a really nice experience. I've had the effects of caffeine intoxication for the next two days. Lesson learned, I'm staying away from black beans for some time.
If you want the slides, you can find them here.
And that was the end of the day. We went to the party, to the afterparty, we got drunk, we got the soft-reset of our caches, and there came another day of the conference.

You can find my review from the last day in here.

Scalar – będziemy tam z ofertą pracy dla Was

Już w najbliższą sobotę – Scalar – bezpłatna konferencja dla wszystkich zainteresowanych Scalą. TouK ma przyjemność być jednym ze sponsorów wydarzenia. Podczas przerw będziemy rozglądać się za młodszym developerem Scali, więc jeśli jesteś zainteresowany pracą, wypatruj ludzi z TouK. This Saturday – Scalar – a free conference for funs and enthusiast of Scala. TouK has a pleasure to co-sponsor the event. During breaks we'll also look out for a junior Scala developers, so if you're interested, look out for TouK people.