December 16, 2012

Devoxx 2012 review

I'm sitting in a train to Charleroi, looking through a window at the Denmark landscape, street lights flashing by, people comming home from work, getting out for a Friday night party, or having a family dinner. To my left, guys from SoftwareMill are playing cards.
I don't really see them. My mind is busy elsewhere, sorting out and processing last two days in Antwerp, where 3400 developers, from 41 different countries, listened to 200 different sessions at the Devoxx, AFAIK the biggest Java conference this year.
Some talks were so popular, that people were siting on the stairs.
It was an interesting experience, watching the show, after six conferences in Poland that I've been to this year. Everything about Devoxx is bigger. The venue is called Cinemapolis, and as you'd expect, it's a cinema complex. At the ground level you can find a lot of the most important Vendors in the Java world. SpringSource, Typesafe, Jetbrains, JBoss, RedHat, IBM, ZeroTurnaround, 10 Gen, Atlassian, and many others, have their people presenting latests products, giving away t-shirts, books, or just asking for feedback. Google stands on the opposite side to Oracle, as expected, but you won't see them fighting each other. There are no lawyers and their bullshit in here, there are devs and devs only.
The main hall is where most of the vendors are at
For those needed extra charge, or a hackaton, long tables with plenty of power outputs were provided.
Grzegorz Duda (33rd) with Stephan Janssen (Devoxx)

A conference day starts very early to my standards (8 am) and so do keynotes, at 9:30. There are seven large cinema rooms at our disposal, and keynotes are streamed from the room where the whole show takes place to a big ass cinema screens and movie level sound system, so you feel just like you were just in front of the scene, no matter where you sit. 

After keynotes, normal sessions start, and go on till 7pm, with one half an hour break for a coffee and another one hour for lunch. Lunch is rather blunt, and the queue is long. My friends, who are organizing Confitura, Geecon and 33rd, say that you'd be overwhelmed with bad press if you tried something like this in Poland. Perhaps it's the nature of our nation to be always bitching, but fortunately, people here seem not to mind, and we certainly don't. With so much things going on, you find hardly any time, to even take a piss, so you tend to just swallow the food as fast as possible and get back to talks, vendors and socializing.

There's a plenty of ways vendors will try to get your attention for a while. All of them are fun.
Talking about the last one, I've been traveling to Antwerp with Grzegorz Duda, but we met half of SoftwareMill at the Modlin airport, and we were meeting more and more Poles on the way. During the conference, there were whiteboards where someone would post a question, and people would mark answers. One of them was “Where're you from?”, and as you can see from this picture, Polish representation was rather strong.
While you could have all the smalltalks with interesting people, that you would like, socializing is not really something that conference days of Devoxx shine with. First, with so many interesting talks packed up, there is little time for chatter, and second, such a huge crowd makes the interaction harder. Just a few weeks before, I had been to TopConf in Tallinn, which is a conference with perhaps 200 people, but it somehow makes everyone important, brings people together to talk, get to know each other, and leave the secure area of their own groups. In Devoxx, it's more like a rock concert, where you go with your friends, have fun with everybody, but don't get to know too many people really well. And the party of the second day, doesn't help much. It's in a club called Noxx, just next to the cinema, the conference is in, and I've heard it's the second largest club in Europe. It's a typical 'club' club, with club music, several dance floors, drink bars, and little else. The problem is, with 3400 devs, mostly male, you kind of end up with a large gay party, and the music is way too loud to talk with anyone. You can throw yourself into trance, and have really good fun, but don't count on getting to know any of the people.
So if you want interaction, choose BOFs, Labs, or the University day in general, instead of the regular conference days. Or just try the very long tables, where people could get their laptops and phones charged, do some work or show off some cool stuff to their friends.
RFID bracelet. Surprisingly durable, survived three showers with ease.

Back to the talks, after every one, on your way out, you could vote thumb-up, or thumb-down with your RFID bracelet, that you were ringed with, on your sign-up. This would get pushed to a node.js server, running on Raspberry Pi, and you'd be able to see in real time, which talks were the best. At least in theory, because the system didn't survive the real life experiment, because people were either confusing up and down, not leaving the room waiting for another talk (and this not voting), or voting for a wrong lecture.

Raspberry Pi was everywhere at the conference. Guys from Oracle would show us their new JVM build specifically for this device, to facilitate floating point hardware, and run latests JavaFX 2.0 on it (which, finally doesn't suck anymore, though doesn't get your jaw drop down either), but you'll have to wait a bit for it, since it's not yet public. Inspired by the show, I've ordered one, together with nine other guys here at TouK. Let's see what a cluster of Raspberries can do for you.

I cannot really describe all the talks. I've seen just 1/7 of the conference, and I have a notebook full of notes, but most of them are just 'a-ha' kind of remarks, when I've heard something really useful, like how to make a difference between your HTTP 403, and some new badly-configured firewall on the way, when you are building a fully REST-to-the-bones, services, with all HTTP statuses and so on, or why there'll be multi-inheritance of behavior in Java 8, and why it's not dangerous compared to multi-inheritance of state, or how the interfaces may have a default implementation in Java 8+, and why it's such a smart solution to the problem of backward compatibility and the need for a completely fresh collections API. All the Devoxx talks should be available soon on (which was rewritten in HTML5, by the way), and though they charge for viewing, I think it's worth you bucks.

So as we are down to money, here is a question I'd like to answer:

Assuming you have limited resources, and wonderful, local, much cheaper conferences, like we do in Poland, is it better to go for, say three local conferences like GeeCon, 33rd, and JDD, or to go to Devoxx?

The answer depends on what you expect from a conference.

If you want knowledge, GeeCon + 33rd + JDD will probably be better, just because while Devoxx has 7 tracks, you can only be on one at a time.

If you want inspiration and to feed on the passion of others, GeeCon + 33rd + JDD will be better, just because those are quite nicely distributed over the whole year (especially if you include free Confitura and Warsjava in the line-up).

If, however, time is your problem, and you have only so much to go to one conference that year, then Devoxx has a slight advantage in my opinion. Not a big one, but still.

On our way home.

The plane is circling over the Modlin airport, as I'm talking with Paweł Wrzeszcz about how much we both are scared giving public talks. Outside the window a thick fog surrounds us so closely, that I am unable to see the tip of the aircraft's wing. The captain explains over intercom, that Modlin lacks necessary radio hardware to guide us safely down, so we are heading to Chopin Airport in Warsaw. People applause loudly, as most, if not all of them, are heading to/through Warsaw anyway, and fly from Modlin only because it's cheaper.

We are slowly moving over the city.

The plane is loosing altitude, and I confess to Paweł, that I'm just as afraid of flying as I'm afraid of talking at conferences. This isn't the fear he shares with me, but I can see he's a bit uneasy too. The fog outside the window is milky white, and I can't see even the middle of the wing through it now. The plain starts vibrating, last corrections are being made. We are flying by the radio signal, which comes from some hardware on the airfield, for which some programmer wrote software some time ago.

And then we hit the ground.

And we stop.

People clap their hands with relief. Here's the standing ovation, here's the big thank you for the captain. And the crew.

And, perhaps, even though most people don't know it, perhaps also for the programmer who wrote that marvelous piece of software, which allowed us to land safely.

That's what I choose to think.

October 15, 2012

Friends with benefits

Back when I was at my first university, working on my B.Sc., it was obvious for us, students, to always try to get into any possible, open IT event in the town. We were hungry for knowledge, for experience, anxious looking at the future.

One of the really bad professors out there, told us on the first lecture, that whatever we learn is going to be outdated the moment we learn it. He said that we won't be able to keep up the pace, that we will burn out, we will be replaced by some newfags before we even learn to do the job. And there is no hope for us.

It wasn't a good university, it was a young one. A young university in a small town, with very old professors. Some of those guys were there, because no one else would take them. So yeah, we were anxious. Anxious that we are not getting any good education, anxious we will not find a good job afterwards, anxious we will become burned out before we know it.

But we were also very young, young enough to believe, we won't be giving it up without a fight. And thus we were learning on our own, reading books, coding, getting together and sharing what little knowledge we had. And we applied for every interesting position around, to get as much experience as we could.

Not that we had many options. As I said, it was a small town.

After B.Sc., I moved to Warsaw. Started my M.Sc. at another university, which turned out to be no better, but it didn't matter any more. I had a good job as a programmer, with fantastic, smart people. In half a year, I learned more, than in five years at all the universities.

Then I moved to another company. Changed the technology stack completely. Started anew, and had great time learning from all those smart people around me, and teaching them whatever I could.

And there was not a single event I would attend to, or hear anybody do it. It seemed like a thing of the past. We had so much knowledge to learn inside the company, why move, why go anywhere at all?

And then I switched my technology stack again. I joined TouK. This time, however, it seemed like I could spread a lot more knowledge about TDD, OOP and good practices, than before. But to do that, I had to fill the holes in my knowledge really fast. So I got myself some books, some RSS'es, some tutorials. One day, my boss sent us an invitation for a Warsaw Java User Group meeting. Some guys were coming. I signed up to the mailing group, and off I went.

There I was, back at the University, getting to know other hairy guys at WJUG meetings, learning about their craft, their interests, and their passions. Encouraged by someone, I went to a conference. Then another. I started attending conferences on regular basis. Actually, I started attending all the Java conferences in Poland. And there are quite a few, I tell you.

Something strange happened. Apart from the technologies, personal experiences, tricks and traps, I learned something completely different. I knew I was getting tired by everyday work, that my energy was much higher after right after holidays, and I'd be much less efficient just before one. I knew I could find myself burned out, one day. I heard a story here and there, in the kitchen, over the coffee table. Someone with a sad look would mention, he has no fun anymore. The job became tiresome. Someone would talk about buying a farm. Or a workshop. Getting out of this line of work.

But at those WJUG meetings, at those conferences, my energy was replenished. The enthusiasm and passion for cool technology, hanging right out in the air, would be contagious. The people, with eyes burning bright for great things they could learn and bring back home... I could feel their hunger for knowledge. And I was back, to my student years again, feeling everything is possible. Not anxious about my future this time.

That was great.

I wanted to help those, who make it happen. To somehow thank them. And I could do that in two ways: either by helping organize, or by sharing what I knew. I prepared a small presentation about Craftsmanship for WJUG, and got a positive feedback. Then I had another, about Spring Security, and another, and so on. Then I answered a call for papers, and got myself speaking at conferences. And it was great too. I joined another great group, Agile Warsaw. I even organized a weekly workshop, here at TouK, to get all the shy people to share, and learn how good it feels.

I have to confess, though. Speaking at conferences is a terrible strain for an anti-social, hairy guy like me. There is so much stress involved. If I wanted to be in spotlights, I wouldn't become a programmer in the first place. No one digs inside computers, because of love for humanity, I suppose.

Local group meetings, like WJUG, are a completely different story, however. Those are semi-formal, with 50-150 people in an old University assembly hall, with half of them hairy sociopaths in Amiga Forever T-shirts or alike, with beards that would make Richards Stallman proud, swearing like Linus Torvalds when he was thanking Nvidia, and making jokes that would fit right into, xkcd or the Jargon File. It feels good to be around them. It feels at home.

This is as close to demoscene-kind-of-feeling, as my old ass gets. Preparing a talk for them, apart from motivating me to dig the subject thoroughly, is even better.

One of the unforeseen consequences of getting out to conferences and meetings, is that you get a lot of cool gadgets. A hat from oracle, a ninja coder from Amazon, an energy drink from Microsoft with Linux/PHP/Ruby all over it, a nerd pistol, tons of T-shirts. I didn't have to buy a T-shirt for years. Sometimes, you even get a licence or a ticket.

Thanks to WJUG, I have the IntelliJ Idea and JProfiler, both of which are extremely good and handy pieces of software.

And yesterday... well yesterday, I got a ticket for Devoxx in Belgium, saving me a few hundred Euros.

So in case you didn't already, get your lazy ass out, and join a local technology group, go to conferences, write a blog, share with people. You'll be surprised by the unforeseen benefits.

Even if you are a hairy sociopath, like me.

September 17, 2012

Test Driven Traps, part 2

The Story of a Unit in Unit Tests

In the previous part of this article, you could see some bad, though popular, test samples. But I'm not a professional critic (also known as a troll, or a hater), to grumble about without having anything constructive to say. Years of TDD have taught me more than just how bad the things can go. There are many simple but effective tricks, that can make you test-life much easier.

Imagine this: you have a booking system for a small conference room in a small company. By some strange reason, it has to deal with off-line booking. People post their booking requests to some frontend, and once a week you get a text file with working hours of the company, and all the bookings (for what day, for how long, by whom, submitted at what point it time) in random order. Your system should produce a calendar for the room, according to some business rules (first come, first served, only in office business hours, that sort of things).

As part of the analysis, we have a clearly defined input data, and expected outcomes, with examples. Beautiful case for TDD, really. Something that sadly never happens in the real life.

Our sample test data looks like this:

class TestData {
    static final String INPUT_FIRST_LINE = "0900 1730\n";
    static final String FIRST_BOOKING    = "2011-03-17 10:17:06 EMP001\n" +
                                           "2011-03-21 09:00 2\n";
    static final String SECOND_BOOKING   = "2011-03-16 12:34:56 EMP002\n" +
                                           "2011-03-21 09:00 2\n";
    static final String THIRD_BOOKING    = "2011-03-16 09:28:23 EMP003\n" +
                                           "2011-03-22 14:00 2\n";
    static final String FOURTH_BOOKING   = "2011-03-17 10:17:06 EMP004\n" +
                                           "2011-03-22 16:00 1\n";
    static final String FIFTH_BOOKING    = "2011-03-15 17:29:12 EMP005\n" +
                                           "2011-03-21 16:00 3";

    static final String INPUT_BOOKING_LINES =
                                            FIRST_BOOKING +
                                            SECOND_BOOKING +
                                            THIRD_BOOKING +
                                            FOURTH_BOOKING +


    static final String CORRECT_OUTPUT = "2011-03-21\n" +
                                         "09:00 11:00 EMP002\n" +
                                         "2011-03-22\n" +
                                         "14:00 16:00 EMP003\n" +
                                         "16:00 17:00 EMP004\n" +

So now we start with a positive test:

BookingCalendarGenerator bookingCalendarGenerator =  new BookingCalendarGenerator();

public void shouldPrepareBookingCalendar() {
    String calendar = bookingCalendarGenerator.generate(TestData.CORRECT_INPUT);

    assertEquals(TestData.CORRECT_OUTPUT, calendar);

It looks like we have designed a BookingCalendarGenerator with a “generate” method. Fair enough. Lets add some more tests. Tests for the business rules. We get something like this:

    public void noPartOfMeetingMayFallOutsideOfficeHours() {
        String tooEarlyBooking = "2011-03-16 12:34:56 EMP002\n" +
                                 "2011-03-21 06:00 2\n";

        String tooLateBooking = "2011-03-16 12:34:56 EMP002\n" +
                                "2011-03-21 20:00 2\n";

        String calendar = bookingCalendarGenerator.generate(TestData.INPUT_FIRST_LINE + tooEarlyBooking + tooLateBooking);


    public void meetingsMayNotOverlap() {
        String firstMeeting = "2011-03-10 12:34:56 EMP002\n" +
                              "2011-03-21 16:00 1\n";

        String secondMeeting = "2011-03-16 12:34:56 EMP002\n" +
                               "2011-03-21 15:00 2\n";

        String calendar = bookingCalendarGenerator.generate(TestData.INPUT_FIRST_LINE + firstMeeting + secondMeeting);

        assertEquals("2011-03-21\n" +
                     "16:00 17:00 EMP002\n", calendar);

    public void bookingsMustBeProcessedInSubmitOrder() {
        String firstMeeting = "2011-03-17 12:34:56 EMP002\n" +
                              "2011-03-21 16:00 1\n";

        String secondMeeting = "2011-03-16 12:34:56 EMP002\n" +
                               "2011-03-21 15:00 2\n";

        String calendar = bookingCalendarGenerator.generate(TestData.INPUT_FIRST_LINE + firstMeeting + secondMeeting);

        assertEquals("2011-03-21\n15:00 17:00 EMP002\n", calendar);

    public void orderingOfBookingSubmissionShouldNotAffectOutcome() {
        List<String> shuffledBookings = newArrayList(TestData.FIRST_BOOKING, TestData.SECOND_BOOKING,
                TestData.THIRD_BOOKING, TestData.FOURTH_BOOKING, TestData.FIFTH_BOOKING);
        String inputBookingLines = Joiner.on("\n").join(shuffledBookings);

        String calendar = bookingCalendarGenerator.generate(TestData.INPUT_FIRST_LINE + inputBookingLines);

        assertEquals(TestData.CORRECT_OUTPUT, calendar);

That's pretty much all. But what if we get some rubbish as the input. Or if we get an empty string? Let's design for that:

    @Test(expected = IllegalArgumentException.class)
    public void rubbishInputDataShouldEndWithException() {
        String calendar = bookingCalendarGenerator.generate("rubbish");

        //then exception is thrown

    @Test(expected = IllegalArgumentException.class)
    public void emptyInputDataShouldEndWithException() {
        String calendar = bookingCalendarGenerator.generate("");

        //then exception is thrown

IllegalArgumentException is fair enough. We don't need to handle it in any more fancy way. We are done for now. Let's finally write the class under the test: BookingCalendarGenerator.

And so we do. And it comes out, that the whole thing is a little big for a single method. So we use the power of Extract Method pattern. We group code fragments into different methods. We group methods and data those operate on, into classes. We use the power of Object Oriented programming, we use Single Responsibility Principle, we use composition (or decomposition, to be precise) and we end up with a package like this:

We have one public class, and several package-scope classes. Those package scope classes clearly belong to the public one. Here's a class diagram for clarity:

Those aren't stupid data-objects. Those are full fledged classes. With behavior, responsibility, encapsulation. And here's a thing that may come to our Test Driven minds: we have no tests for those classes. We have only for the public class. That's bad, right? Having no tests must be bad. Very bad. Right?


We do have tests. We fire up our code coverage tool and we see: 100% methods and classes. 95% lines. Not bad (I'll get to that 5% of uncertainty in the next post).

But we have only a single unit test class. Is that good?

Well, let me put some emphasis, to point the answer out:

It's a UNIT test. It's called a UNIT test for a reason!

The unit does not have to be a single class. The unit does not have to be a single package. The unit is up to you to decide. It's a general name, because your sanity, your common sense, should tell you where to stop.

So we have six classes as a unit, what's the big deal? How about if somebody wants to use one of those classes, apart from the rest. He would have no tests for it, right?

Wrong. Those classes are package-scope, apart from the one that's actually called in the test. This package-scope thing tells you: “Back off. Don't touch me, I belong to this package. Don't try to use me separately, I was design to be here!”.

So yeah, if a programmer takes one of those out, or makes it public, he would probably know, that all the guarantees are voided. Write your own tests, man.

How about if somebody wants to add some behavior to one of those classes, I've been asked. How would he know he's not breaking something?

Well, he would start with a test, right? It's TDD, right? If you have a change of requirements, you code this change as a test, and then, and only then, you start messing with the code. So you are safe and secure.

I see people writing test-per-class blindly, without giving any thought to it, and it makes me cry. I do a lot of pair-programming lately, and you know what I've found? Java programmers in general do not use package-scope. Java programmers in general do not know, that protected means: for me, all my descendants, and EVERYONE in the same package. That's right, protected is more than package-scope, not less a single bit. So if Java programmers do not know what a package-scope really is, and that's, contrary to Groovy, is the default, how could they understand what a Unit is?

How high can I get?

Now here's an interesting thought: if we can have a single test for a package, we could have a single test for a package tree. You know, something like this:

We all know that packages in Java are not really tree-like, that the only thing those have with the directory structure is by a very old convention, and we know that the directory structure is there only to solve the collision-of-names problem, but nevertheless, we tend to use packages, like if the had some meaning. Like if we could hide one package inside another. Or build layers of lasagne with them.

So is it O.K. to have a single test class for a tree of packages?

Yes it is.

But if so, where is the end to that? Can we go all the way up in the package tree, to the entry point of our application? Those... those would be integration tests, or functional tests, perhaps. Could we do that? Would that be good?

The answer is: it would. In a perfect world, it would be just fine. In our shitty, hanging-on-the-edge-of-a-knife, world, it would be insane. Why? Because functional, end-to-end test are slow. So slow. So horribly slow, that it makes you wanna throw them away and go some place where you would not have to be always waiting for something. A place of total creativity, constant feedback, and lightning fast safety.

And you're back to unit testing.

There are even some more reasons. One being, that it's hard to test all flows of the application, testing it end-to-end. You should probably do that for all the major flows, but what about errors, bad connections, all those tricky logic parts that may throw up at one point or another. No, sometimes it would be just too hard, to set up the environment for integration test like that, so you end up testing it with unit tests anyway.

The second reason is, that though functional tests do not pour concrete over your code, do not inhibit your creativity by repeating you algorithm in the test case, they also give no safety for refactoring. When you had a package with a single public class, it was quite obvious what someone can safely do, and what he cannot. When you have something enclosed in a library, or a plugin, it's still obvious. But if you have thousands of public classes, and you are implementing a new feature, you are probably going to use some of them, and you would like to know that they are fine.

So, no, in our world, it doesn't make sense to go with functional tests only. Sorry. But it also doesn't make sense to create a test per class. It's called the UNIT test, for a reason. Use that.

September 16, 2012

Test Driven Traps, part 1

Have you ever been in a situation, where a simple change of code, broke a few hundred tests? Have you ever had the idea that tests slow you down, inhibit your creativity, make you afraid to change the code. If you had, it means you've entered the Dungeon-of-very-bad-tests, the world of things that should not be.

I've been there. I've built one myself. And it collapsed killing me in the process. I've learned my lesson. So here is the story of a dead man. Learn from my faults or be doomed to repeat them.

The story

Test Driven Development, like all good games in the world, is simple to learn, hard to master. I've started in 2005, when a brilliant guy named Piotr Szarwas, gave me the book “Test Driven Development: By Example” (Kent Beck), and one task: creating a framework.

These were the old times, when the technology we were using had no frameworks at all, and we wanted a cool one, like Spring, with Inversion-of-Control, Object-Relational Mapping, Model-View-Controller and all the good things we knew about. And so we created a framework. Then we built a Content Management System on top of it. Then we created a bunch of dedicated applications for different clients, Internet shops and what-not, on top of those two. We were doing good. We had 3000+ tests for the framework, 3000+ tests for the CMS, and another few thousand for every dedicated application. We were looking at our work, and we were happy, safe, secure. These were good times.

And then, as our code base grew, we came to the point, where a simple anemic model we had, was not good enough anymore. I had not read the other important book of that time: “Domain Driven Design”, you see. I didn't know yet, that you can only get so far with an anemic model.

But we were safe. We had tons of tests. We could change anything.

Or so I thought.

I spent a week trying to introduce some changes in the architecture. Simple things really: moving methods around, switching collaborators, such things. Only to be overwhelmed by the number of tests I had to fix. That was TDD, I started my change with writing a test, and when I was finally done with the code under the test, I'd find another few hundred tests completely broken by my change. And when I got them fixed, introducing some more changes in the process, I'd find another few thousand broken. That was a butterfly effect, a chain reaction caused by a very small change.

It took me a week to figure out, that I'm not even half done in here. The refactoring had no visible end. And at no point my code base was stable, deployment-ready. I had my branch in the repository, one I've renamed "Lasciate ogne speranza, voi ch'intrate".

We had tons and tons of tests. Of very bad tests. Tests that would pour concrete over our code, so that we could do nothing.

The only real options were: either to leave it be, or delete all tests, and write everything from scratch again. I didn't want to work with the code if we were to go for the first option, and the management would not find financial rationale for the second. So I quit.

That was the Dungeon I built, only to find myself defeated by its monsters.

I went back to the book, and found everything I did wrong in there. Outlined. Marked out. How could I skip that? How could I not notice? Turns out, sometimes, you need to be of age and experience, to truly understand the things you learn.

Even the best of tools, when used poorly, can turn against you. And the easier the tool, the easier it seems to use it, the easier it is to fall into the trap of I-know-how-it-works thinking. And then BAM! You're gone.

The truth

Test Driven Development and tests, are two completely different things. Tests are only a byproduct of TDD, nothing more. What is the point of TDD? What does TDD brings? Why do we do TDD?

Because of three, and only those three reasons.

1. To find the best design, by putting ourselves into the user's shoes.

By starting with “how do I want to use it” thinking, we discover the most useful and friendly design. Always good, quite often that's the best design out there. Otherwise, what we get is this:

And you don't want that.

2. To manage our fear.

It takes balls, to make a ground change in a large code-base without tests, and say “it's done” without introducing bugs in the process, doesn't it? Well, the truth is, if you say “it's done”, most of the time you are either ignorant, reckless, or just plain stupid. It's like with concurrency: everybody knows it, nobody can do it well.

Smart people are scared of such changes. Unless they have good tests, with high code coverage.

TDD allows to manage our fears, by giving us proof, that things work as they should. TDD gives us safety

3. To have fast feedback.

How long can you code, without running the app? How long can you code without knowing whether your code works as you think it should?

Feedback in tests is important. Less so for frontend programming, where you can just run the shit up, and see for yourselves. More for coding in the backend. Even more, if your technology stack requires compilation, deployment, and starting up.

Time is money, and I'd rather earn it, than wait for the deployment and click through my changes each time I make them.

And that's it. There are no more reasons for TDD whatsoever. We want Good Design, Safety, and Feedback. Good tests are those, which give us that.

Bad tests?

All the other tests are bad.

The bad practice

So how does a typical, bad test, look like? The one I see over and over, in close to every project, created by somebody who has yet to learn how NOT to build an ugly dungeon, how not to pour concrete over your code base. The one I'd write myself in 2005.

This will be a Spock sample, written in groovy, testing a Grails controller. But don't worry if you don't know those technologies. I bet you'll understand what's going on in there without problems. Yes, it's that simple. I'll explain all the not-so-obvious parts.

def "should show outlet"() {
    def outlet = OutletFactory.createAndSaveOutlet(merchant: merchant)
    response.redirectUrl == null

So we have a controller. It's an outlet controller. And we have a test. What's wrong with this test?

The name of the test is “should show outlet”. What should a test with such a name check? Whether we show the outlet, right? And what does it check? Whether we are redirected. Brilliant? Useless.

It's simple, but I see it all around. People forget, that we need to:


I bet that test was written after the code. Not in test-first fashion.

But verifying the right thing is not enough. Let's have another example. Same controller, different expectation. The name is: "should create outlet insert command with valid params with new account"

Quite complex, isn't it? If you need an explanation, the name is wrong. But you don't know the domain, so let me put some light on it: when we give the controller good parameters, we want it to create a new OutletInsertCommand, and the account of that one, should be new.

The name doesn't say what 'new' is, but we should be able to see it in the code.

Have a look at the test:

def "should create outlet insert command with valid params with new account"() {
    def defaultParams = OutletFactory.validOutletParams
    1 * securityServiceMock.getCurrentlyLoggedUser() >> user
    1 * commandNotificationServiceMock.notifyAccepters(_)
    0 * _._
    Outlet.count() == 0
    OutletInsertCommand.count() == 1
    def savedCommand = OutletInsertCommand.get(1)
    savedCommand.mobileMoneyAccountNumber == '1000000000000'
    savedCommand.accountType == CyclosAccountType.NOT_AGENT
    controller.flash.message != null
    response.redirectedUrl == '/outlet/list'

If you are new to Spock: n*mock.whatever(), means that the method “whatever” of the mock object, should be called exactly n times. No more no less. The underscore “_” means “everything” or “anything”. And the >> sign, instructs the test framework to return the right side argument when the method is called.

So what's wrong with this test? Pretty much everything. Let's go from the start of “then” part, mercifully skipping the oververbose set-up in the “given”.

1 * securityServiceMock.getCurrentlyLoggedUser() >> user

The first line verifies whether some security service was asked for a logged user, and returns the user. And it was asked EXACTLY one time. No more, no less.

Wait, what? How come we have a security service in here? The name of the test doesn't say anything about security or users, why do we check it?

Well, it's the first mistake. This part is not, what we want to verify. This is probably required by the controller, but it only means it should be in the “given”. And it should not verify that it's called “exactly once”. It's a stub for God's sake. The user is either logged in or not. There is no sense in making him “logged in, but you can ask only once”.

Then, there is the second line.

1 * commandNotificationServiceMock.notifyAccepters(_)

It verifies that some notification service is called exactly once. And it may be ok, the business logic may require that, but then... why is it not stated clearly in the name of the test? Ah, I know, the name would be too long. Well, that's also a suggestion. You need to make another test, something like “should notify about newly created outlet insert command”.

And then, it's the third line.

0 * _._

My favorite one. If the code is Han Solo, this line is Jabba the Hut. It wants Hans Solo frozen in solid concrete. Or dead. Or both.

This line, if you haven't deducted yet, is “You shall not make any other interactions with any mock, or stubs, or anything, Amen!”.

That's the most stupid thing I've seen in a while. Why would a sane programmer ever put it here? That's beyond my imagination.

No it isn't. Been there, done that. The reason why a programmer would use such a thing is to make sure, that he covered all the interactions. That he didn't forget about anything. Tests are good, what's wrong in having more good?

He forgot about sanity. That line is stupid, and it will have it's vengeance. It will bite you in the ass, some day. And while it may be small, because there are hundreds of lines like this, some day you gonna get bitten pretty well. You may as well not survive.

And then, another line.

Outlet.count() == 0

This verifies whether we don't have any outlets in the database. Do you know why? You don't. I do. I do, because I know the business logic of this domain. You don't because this tests sucks at informing you, what it should.

Then there is the part, that actually makes sense.

    OutletInsertCommand.count() == 1
    def savedCommand = OutletInsertCommand.get(1)
    savedCommand.mobileMoneyAccountNumber == '1000000000000'
    savedCommand.accountType == CyclosAccountType.NOT_AGENT

We expect the object we've created in the database, and then we verify whether it's account is “new”. And we know, that the “new” means a specific account number and type. Though it screams for being extracted into another method.

And then...

    controller.flash.message != null
    response.redirectedUrl == '/outlet/list'

Then we have some flash message not set. And a redirection. And I ask God, why the hell are we testing this? Not because the name of the test says so, that's for sure. The truth is, that looking at the test, I can recreate the method under test, line by line.

Isn't it brilliant? This test represents every single line of a not so simple method. But try to change the method, try to change a single line, and you have big chance to blow this thing up. And when those kinds of tests are in the hundreds, you have concrete all over you code. You'll be able to refactor nothing.

So here's another lesson. It's not enough to verify the right thing. You need to


Never ever verify the algorithm of the method step by step. Verify the outcomes of the algorithm. You should be free to change the method, as long as the outcome, the real thing you expect, is not changed.

Imagine a sorting problem. Would you verify it's internal algorithm? What for? It's got to work and it's got to work well. Remember, you want good design and security. Apart from this, it should be free to change. Your tests should not stay in the way.

Now for another horrible example.

@Unroll("test merchant constraints field #field for #error")
def "test merchant all constraints"() {
    def obj = new Merchant((field): val)

    validateConstraints(obj, field, error)

    field                     | val                                    | error
    'name'                    | null                                   | 'nullable'
    'name'                    | ''                                     | 'blank'
    'name'                    | 'ABC'                                  | 'valid'
    'contactInfo'             | null                                   | 'nullable'
    'contactInfo'             | new ContactInfo()                      | 'validator'
    'contactInfo'             | ContactInfoFactory.createContactInfo() | 'valid'
    'businessSegment'         | null                                   | 'nullable'
    'businessSegment'         | new MerchantBusinessSegment()          | 'valid'
    'finacleAccountNumber'    | null                                   | 'nullable'
    'finacleAccountNumber'    | ''                                     | 'blank'
    'finacleAccountNumber'    | 'ABC'                                  | 'valid'
    'principalContactPerson'  | null                                   | 'nullable'
    'principalContactPerson'  | ''                                     | 'blank'
    'principalContactPerson'  | 'ABC'                                  | 'valid'
    'principalContactInfo'    | null                                   | 'nullable'
    'principalContactInfo'    | new ContactInfo()                      | 'validator'
    'principalContactInfo'    | ContactInfoFactory.createContactInfo() | 'valid'
    'feeCalculator'           | null                                   | 'nullable'
    'feeCalculator'           | new FixedFeeCalculator(value: 0)       | 'valid'
    'chain'                   | null                                   | 'nullable'
    'chain'                   | new Chain()                            | 'valid'
    'customerWhiteListEnable' | null                                   | 'nullable'
    'customerWhiteListEnable' | true                                   | 'valid'
    'enabled'                 | null                                   | 'nullable'
    'enabled'                 | true                                   | 'valid'

Do you understand what's going on? If you haven't seen it before, you may very well not. The “where” part, is a beautiful Spock solution for parametrized tests. The headers of those columns are the names of variables, used BEFORE, in the first line. It's sort of a declaration after the usage. The test is going to be fired many times, once for for each line in the “where” part. And it's all possible thanks to Groovy's Abstract Syntaxt Tree Transofrmation. We are talking about interpreting and changing the code during the compilation. Cool stuff.

So what this test is doing?


Let me show you the code under test.

static constraints = {
  name(blank: false)
  contactInfo(nullable: false, validator: { it?.validate() })
  businessSegment(nullable: false)
  finacleAccountNumber(blank: false)
  principalContactPerson(blank: false)
  principalContactInfo(nullable: false, validator: { it?.validate() })
  feeCalculator(nullable: false)
  customerWhiteListEnable(nullable: false)

This static closure, is telling Grails, what kind of validation we expect on the object and database level. In Java, these would most probably be annotations.

And you do not test annotations. You also do not test static fields. Or closures without any sensible code, without any behavior. And you don't test whether the framework below (Grails/GORM in here) works the way it works.

Oh, you may test that for the first time you are using it. Just because you want to know how and if it works. You want to be safe, after all. But then, you should probably delete this test, and for sure, not repeat it for every single domain class out there.

This test doesn't event verify that, by the way. Because it's a unit test, working on a mock of a database. It's not testing the real GORM (Groovy Object-Relational Mapping, an adapter on top of Hibernate). It's testing the mock of the real GORM.

Yeah, it's that stupid.

So if TDD gives us safety, design and feedback, what does this test provide? Absolutely nothing. So why did the programmer put it here? Because his brain says: tests are good. More tests are better.

Well, I've got news for you. Every single test which does not provide us safety and good design is bad. Period. Those which provide only feedback, should be thrown away the moment you stop refactoring your code under the test.

So here's my lesson number three:


That was the example of things gone wrong. What should we do about it?

The answer: delete it.

But I yet have to see a programmer who removes his tests. Even so shitty as this one. We feel very personal about our code, I guess. So in case you are hesitating, let me remind you what Kent Beck wrote in his book about TDD:

The first criterion for your tests is confidence. Never delete a test if it reduces your confidence in the behavior of the system.

The second criterion is communication. If you have two tests that exercise the same path through the code, but they speak to different scenarios for a readers, leave them alone.

[Kent Beck, Test Driven Development: by Example]

Now you know, it's safe to delete it.

So much for today. I have some good examples to show, some more stories to tell, so stay tuned for part 2.

May 22, 2012

NextBeer, a sample OpenApi application for T-Mobile

Last summer I responded to a request for proposal from T-Mobile in Poland. This rather large telco, wanted to share its services in an easy way on-line, so that every little private developer could use them, a bit like Facebook/Amazon does. We got the job, though the news came so late, I had already started another project (for yet another telco), and as an effect, could not participate in the one for T-Mobile.

The project has a fitting name: OpenApi, because that's what it really is. An open API for everyone who wants to use it. I've heard there was an initiative, to build a common API for all telcos, quite a smart move which would ease creating applications even further, but for now it's custom designed and build.

My friends finished coding a portal for developers, and I was asked to write a sample application. It made a lot of sense to me: the guys deeply in the guts of the system, should not create samples – their perspective is different to real users. I, on the other hand, while knowing what the system is supposed to do (I wrote the proposal together with Piotr Jagielski), haven't seen in yet.

And so, a sample application was born, created in Grails, though a bit Java-style (I wanted to keep it familiar to all those Java/C# folks, who know no Groovy).

The user story is simple. It's Friday, late evening, you are sitting in a pub, together with your friends, but the place is going to be closed at 10pm, which is very unfortunate, as the sweet brunette on your right has just noticed your presence.

You need to move the party forward, to another place, so you take your shiny, last-gen iSmartphone from your pants, only to find out its battery has died. Running all those apps of your design was really demanding.

So the sweet brunette on your right, pulls her old, dumb Nokia, and send an sms. Few minutes later she gets one back, with addresses and phone numbers of all the pubs in 3km range. That's how far she can get on her high hills.

Your party is saved. Your sweet brunette may be truly yours someday. The application which responded to the sms and saved the day, is the sample application I wrote, using OpenAPI and Google Places. It's called: NextBeer.

One picture is worth thousand words, so here is a sequence diagram for the whole thing.

You can find the code on github:

I won't go into details, the code is self documenting, and there is even a nice tutorial for all those who know nothing of Grails (though it's in Polish, as that was the target audience of my example).

If you want to register to OpenAPI, to write your own, go here:

Hope that saves you a nice brunette one day.

May 21, 2012

GeeCON 2012 review

Bruce Almighty!
GeeCON 2012 is over. This year I've decided to go for 3 days, where the first one was a „University day”, and the other two were regular conference days. „University day” is a misleading name, you'd think it's something for students, for beginners perhaps. The idea, as far as I know, was to have a day full of workshops, but as there was just one bring-your-own-laptop TDD workshop, it turned out to be a „normal” conference day, with 2h talks.

Now, „normal” doesn't mean bad. Quite the opposite.

As usually, this is my little review of the conference. Take into account, that with up to 5 parallel tracks, I've seen no more than 25% of the whole event.

Wojtek Erbetowski, pointed out, that as we gain knowledge, it's getting harder and harder to find something amazing at a conference. I was overwhelmed with new knowledge, the first time I went to one, but since I try to keep up to date, since I visit up to six conferences every year, and since speakers tend to give the same talks all over the country, I consider a conference fruitful if I take one thing that can help me in a substantial way.

I'm happy to report, that it was the case with GeeCON.

University Day started for me with Dierk König talking about concurrent programming in Groovy (GPars library). Dierk is a commiter to GPars and a co-author of „Groovy in Action”. Chances are, that if you're using Groovy, you already know the lib, but if you don't, it's got pretty a lot of ways to deal with parallel programming without touching threading manually. It's got STM (Software Transactional Memory), Actors, Agents, Communicating Sequential Processes (CSP), dataflow stuff and more. There's even a thing called KanbanFlow. Yeah, the Kanban in name is not accidental. And the best part: all of this is relativly easy to understand and use.

His talk was good, but to tell the truth, I've seen a GPars presentation at GeeCON 2011, by Václav Pech („Pick low-hanging fruit"), and even though Václav had just an hour, I think his talk was better.

Unfortunatelly, the following Dierk's talk: „Pro Groovy”, was both short (just 1h), and shallow. Dierk was talking about Abstract Syntax Tree transformations, but while I hoped for a show of how to write AST Transformations, Dierk managed only to show a few build in annotations, that were handled by them.

I wish Dierk was available for a whole day. If you are a planning a conference and thinking about whom to invite, please consider asking Dierk and giving him a whole day for a really pro workshop.  That would make my day.
Gavin King and Stéphane Épardaud were introducing us to Ceylon, a new programming language on the JVM. If you are wondering, why should you care about this one, you shouldn't. Give it a few years, and check again. The talk was nice, though.

Then came Bruce Eckel with „Atomic Scala”. Bruce is writing a new book, and the idea he has is to create something for complete newbies in programming, allowing them to learn Scala as the first programming language. The goal is noble, but that means you shouldn't probably buy it, because it's way faster to explain a lot of language constructs comparing to another language you know, than to explain it from the ground up. Bruce's talk was too basic even for such a dumbass as me.

Bruce also gave the opening talk “The Power of Hybridization”, the next day, and thought it lacked a thesis (Bruce had to finish at about 70%), his deep, multilingual perspective and tons of anecdotes, made it very interesting to me. By the way, if you've read about how slides should look like (no text-reading, only slogans, full screen pictures, etc.) Bruce is doing exactly the opposite thing. Nobody cares, when you have something to tell, though.

I'll skip Ivar Jacobson's “Liberating the Essence...” talk, as it lacked.. the essence. I'll also skip Gavin King's “Ceylon: the thinking behind a new language”, as it was just the same thing as with any other Java-replacement language I know of.  Let's move to Adam Bien talking Web Containers and Java EE.

Terminator @pub in Poznań
Adam Bien is a Java Rock Star, Champion, expert, writer, consultant and what else, so you'd correctly assume, his perspective will be very orthodox, especially when you consider that there were at least 4 other languages represented at the conference (Scala, Groovy, Ceylon, Kotlin). But he made a point – the main reason we take all those libs/languages, we change EE containers to web containers + frameworks, is that we do not know Java EE 6 well enough (before 6, using pure Java EE was masochism at best). And then we tend to reimplement/rediscover the things Java EE has already solved.

The thing he misses, though, is that it's easier to learn and use those “other” technologies, than do proper Java EE. And yes, after years of corpo-failures, programmers tend to be biased against Java EE.  Thus, while Java EE is finally good, and it makes perfect sense to stay with Java EE, if you are a Java EE master-blaster, I doubt you'll be as productive as with for example Grails. You'll do good to pick whatever you'd like to learn, and learn it throughly.

Adam's talk was refreshing. Apart from guys from SoftwareMill, I haven't seen anyone talking about Java EE 6 with such expertise and sanity.

And then came my favorite talk. Sam Newman from Thoughtworks, talked about design and architecture with emphasis on rapid release.

Wojtek Erbetowski showing a prototype
of an operating system on top
of a prototype of a hardware
There aren't many talks about architecture at Java conferences. In fact, there are hardly any. I guess  it's easier to fill one hour showing some language basics or a library, than to explain and explore an architecture and its consequences.  Thoughtworks was present at 33rd, with James Lewis and micro services, and I see that the lessons they've learned, are being propagated to other projects. I won't go into details of micro services, as I've already done that reviewing James' talk. Sam was happy to present a case of how to use system decomposition (micro-services at a service per Bounded Context level), and what the effects are.

Some of his learned lessons were:
  • beware of shared lib and serialization protocols (evil for microservices)
  • do not send internal representation of data across the wire (things change)
  • fuck WSDL, go with simple XML, Xpath, and let every service prepare stub-tests, so you can safely change the schema when you want to
  • codify the contract between services with writing a test (the reason is the same as above)
  • do not share database between services; you'll make it impossible to evolve them independently; you can use one database with different schemas
  • data should be owned by the service it uses (similar to above)
When I say I'm interested, and that I see potential here, I really mean it. I'm about to lead a development of a bank system, implementing such an approach. We are already using many small, dedicated to single purpose apps, written in different technologies (Java + Spring MVC, Scala + Play), that communicate via RESTful HTTP, and we are going to expand on that concept. We'll see whether we can keep it so simple as Thoughtworks implies. I'll let you know when we have some outcomes.
I was hopping between presentations for the next hour, as I have either already seen then somwhere else, or was uninspired after a few minutes. Then I went for James Williams, talking about Ratpack. I really feel sorry for James, he made quite a trip here, but as this was the last presentation this day, and he had guys like Bruce Eckel as an alternative, not many people showed up.

I've started the last of the conference with Thomas Sundberg and his rather basic talk about all the wrong things we can do to fail a project. As there was nothing new to me, I left early. Then I moved to Kevlin Henney to listen about OOP in Java (deja-vu? not really), and to Tomasz Kowalczewski talk about Closures in Java 8. That was similar to Simon Ritter at 33rd, but focused solely on Closures. Great talk, nice stuff, Tomasz did great work, though it's a bit disappointing that functions are not going to be first class citizens. Yet.

Oh, well, no reason to go back from Groovy, I guess.

And then there was Piotr Gabryanczyk with Scala, Akka and Camel. That was also a great talk, showing simplicity of programming using those technologies. I wonder how it fits Thoughtworks' micro-services, or are we getting too close to ESB and single point of bullshit that way.

Kevlin Henney closed the conference with examples of cool code. His talk was fantastic, funny, and inspiring. Especially examples. One of the best closing talks I've seen. Thanks.

And there were parties. But that's a completely different story.

Saturday was for Open Spaces, lead by Bruce Eckel, but I couldn't attend.

PS: Some pictures are courtesy of Michał Lewandowski. I've totally forgotten my camera.

March 25, 2012

33rd Degree day 3 review

At the last day of the conference, I've decided to skip the first presentations, and get some sleep instead. I was afraid that Venkat's show is going to be too basic, I will see Jacek Laskowski talking about closure at 4Developers, which I'm kind of supervising from the Java perspective. As an afterthought, I should have gone to see "Static Code Analysis and AST Transformations" by Hamlet D'Arcy, as I really like this guy and the topic is intriguing at least, but I didn't want to intoxicate myself more with coffee, and really needed to get some sleep.

MongoDB: Scaling Web Application

The first talk I've seen was by Ken Sipe. It was a very interesting case study, and I love case studies. They give you a real perspective, unlike the product-half-marketing that some authors are doing, and unlike self-marketing that some "professional" speakers perform. 
Ken had an interesting project at hand: a Facebook like social service, that deals with politic, named GoVote. Half of the presentation was a bit basic, with simple CRUD syntax, but when Ken started to talk about modeling, it got interesting.
Ken used Grails as the web framework and went through several plugins/libs to get him to the performance and efficiency he needed. Every one of them failed, except for GSP, which is a thing worth reflecting about. His lesson was not really surprising: you should not use any abstracts (ORM?), when playing with document databases. He sticked to GORM because of how fast his problems were solved on the mailing list and bug tracker, but GORM doesn't really give you the resolution you want, when dealing with tree structures composed of documents.
My favourite part, albeit short, was about modeling. Ken managed to get ONE hit to DB per dynamic web page, something I've always dreamed of. His advice was to focus on use cases, and design document model with use cases in mind. You get a sign of bad design, when you find nested joins (hitting more than once for the data), and you can usually get away with tags, instead. Interesting stuff, I hope to verify that soon.

HTML5 For Developers

Nathaniel Schutta had a large presentation at hand, nothing he kind fit into only one hour, so he gave us a choice: what do we want to hear about. It turned out, the audience was most interested into Web Workers, local web storage and Canvas. Each had their caveats. 
Web workers allow to get some much needed concurrency  into heavy GUI (or game engines, I guess), work with a simple API where you can handle errors and spawn new workers.
Local storage is unfortunately limited by default to 5MB, and you may get unsuccessful persuading the user to change it. Apart from that, it's a simple key-value store (both Strings), with storage events (think on-insert etc.), but current implementations handle those not without some problems.
Canvas was quite interesting. Though it has a very simple API, and only basic primitives implemented, I've already bought a 500 pages long book about it (and that's without any info on all the libs build on top of it).

Ending keynotes

There were three ending keynotes, one from Nathaniel Schutta, Jurgen Appelo and the last from Robert C. Martin. As expected, those were entertaining, though unless you've been sleeping through the last three years in a cave, you would not be surprised by both craftsman. Jurgen, however, was quite a different animal.
His talk, titled "How to Change the World", was based on his book "Management 3.0" and his work afterwards. I've been interested in the mechanics of change, since I've been trying to change with more or less luck, all the companies I've worked for. Jurgen has a lot to say in that matter, and I've been wrong on so many levels in my attitude towards change, that the talk was very refreshing.
You can take a look at his presentation here:
Overall, while it's too early to say whether that was the best JVM conference in Poland this year, I can recommend 33rd on all grounds. I feel I can bet blindly on it next year. Grzegorz Duda delivers enormous knowledge in so little time and so little money.

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.