My summary for Microxchg.io

If you’re interested in software architecture and distributed systems at all you will have noticed the rise of the term Microservices during the last two years of so. It’s an architectural style that suggests building complex systems out of small independent services rather than taking a monolithic approach. Having looked forward to it for quite a long time, finally, last week, the first conference on the topic took place in Berlin: Microxchg.io

There’s been quite a number of talks at other conferences before, with GOTO Berlin 2014 opening on a related keynote from Martin Fowler and hosting the usual high profile speakers discussing the ideas and principles that comprise the architectural style of microservices. Complemented by the local Meetup communities there has also been a variety of talks about different frameworks and how they would enable building microservices.

Alas, what seemed to be missing was material that contributed at the intersection of these two different approaches to the subject: how do you actually implement a system comprised of microservices, what are the problems you encounter alongside its implementation and how do you deal with those. And it’s no wonder, too, since it will naturally take some time for experience to build up and be articulated. Since the topic has been out there for quite some time now, I had high hopes that Microxchg would stand out from the previously existing contributions — the people involved in the organisation of the conference as well as the line-up of the speakers certainly helped increase those expectations.

So how did it go, was Microxchg able to deliver or was it just another addition to the hype?

The line-up

The two-day conference at the end boasted 28 speakers with some of the usual suspects from James Lewis, Uwe Friedrichsen to Chad Fowler but also names like Adrian Cockcroft who is well known for implementing a microservices architecture at Netflix, Fred George who might have been one of the first people coining the term, and Sam Newman, who just wrote a book on the topic. Alongside a host of lesser known speakers the talks were divided into two tracks, making it possible for an attendee to see fourteen talks over the course of two days. While I looked forward to seeing the big names I was at least as interested in the more practical talks that the other speakers promised. Below I’ll give impressions on some of the ones I have attended. Since all the presentations have been taped it’s worth looking out for the recordings, but I suspect they might take a while to be edited.

Domain Service Aggregators: A Structured Approach to Microservice Composition

James Lewis, whose entertaining talks I have seen a number of times already, opened the conference on track one, so I decided to see Caoilte O’Connor talking about his work with British TV outfit ITV. Specifically, he explained their use of what his team calls Domain Service Aggregators to compose microservices into usable functionality. Apart from the different technical approaches that his team went through in order to avoid coupling services too much, it was interesting to see how they derived their services from the actual domains identified in the presented example. While they started out duplicating data in those services, updating it when the underlying domain service data changed, they later ended up with using HATEOAS for delegation in these aggregation services.

You can find the slides for this talk here,.

Measuring Microservices

Next up was Richard Rodger, CTO of nearForm.com, whose company builds large-scale microservices systems built with NodeJS. He started out with the question how you measure the well-being and health of a human being. His answer was that you – of course – don’t look at cellular processes in a living organism, but rather for some larger scale measurements like heartbeat. Similarly, for a system built from microservices, you should also decide on invariants, that tell you about the state of your application. “Ask not what can go wrong, ask what must go right!” was a key statement there. Additionally, he emphasized that it’s probably not the best investment of your time to pick up the latest fads in technology, but rather educate yourself more formally. Specifically he mentioned TLA+ (“Temporal logic of actions”), a way of “writing high-level specifications of concurrent and distributed systems“, stating that while picking up a new programming language like Go might help you for a few years, whereas picking up TLA+ while help your for your entire career.

The slides to this talk can be found here.

Building Event-Driven Microservices with Scala, Functional Domain Models and Spring Boot

After an interesting talk by Oliver Gierke about the latest contribution from Pivotal named Spring Cloud (certainly worth having a look at in the future!) Chris Richardson took to the stage talking about event-driven microservices. He introduced the audience to Event-Sourcing and Command-Query Responsibility Separation (CQRS) as a way to design scalable systems that reliably handle a large amount of concurrent processes without using concepts like two-phase commit.

Here’s the slides this presentation.

Tipps und Tricks für das Testen von Microservices

This was one of the few talks that were given in german and as I know it’s quite hard to come up with a conclusive testing strategy in distributed systems, I decided to listen to Jörg Pfründer from Hypoport talking about the subject. While others before already touched on Consumer-Driven contracts Jörg explained their strategy which borrows from UI testing in some regards: In a highly dynamic environment you don’t want to statically test everything a service returns but rather think about the specific response properties that a test cares about. Hypoport uses a pattern they call Response Objects (borrowed from Page Objects) that will enable them to write understandable tests that abstract away from the technicalities of retrieving the required results.

On the technical side he mentioned a few interesting frameworks that they are using. Especially WireMock, which I had heard of before, sounded like something worth having a look at.

The slides for this talk are here.

Conclusions

The presentations I liked most where mainly featured on the first day of the conference. This was in part a result of two speakers (Russel Miles and Timo Derstappen) not being able to present on the second day and me having seen the two replacement talks before – those were still great talks, given by Stefan Tilkov and Eberhard Wolff, to be sure.

It’s interesting that most talks made fun of how everyone uses the same buzzwords (Conways law), referring to the same examples (Netflix) and talking about the same libraries (Docker). It’s obvious that we need much more diverse input to evolve the discussion and I think this conference did a good job in providing a stage for many speakers outside of the usual suspects.

Although the conference provided a Code-Of-Conduct that attendees were expected to follow, it featured only one female speaker, Andrea Stubbe from Hybris, and few female attendees. Although the atmosphere didn’t strike me as particularly uninviting for women, this is something that the conference team can probably improve on in the future.

Until now nobody has officially announced a second edition of Microxchg.io, but a lot of attendees already expressed their interest in a sequel and I’m certainly adding myself to that list. I’ll finish with a Thank you for a great conference at an outstanding location to the Microxchg team!

Leave a Reply