Despite its title, this video of the author’s presentation at ACM’s Applicative 2016 conference at New York University (June 2, 2016) covers microservices theory and technical patterns only with just a single (fairly simple) example of a real microservice as possibly encountered in a project.

The presentation tries to cover all the ground including why we see this architectural style emerge today, what specific architectural patterns and principles underlie this style, how one could start developing in a microservices way including challenges and benefits, and what specific technologies support this style. However, it is best in the areas directly dealing with the technical patterns, of which only two are explained in sufficient detail, command query responsibility segregation (CQRS) and event sourcing. Application programming interface (API) gateways and orchestration are only superficially mentioned, and security not at all. Technically, I thoroughly missed any discussion on microservices communications (except by way of sending events).

It is not that the other areas on the agenda are not covered at all: One sees and hears a lot of fully correct jargon (encapsulation, domain-driven design, organizational maturity, reduction in time-to-market, immutable languages, graph databases), but the explanations and elaborations all seem too shallow and too isolated to be really convincing (“Well, you know, in reality that depends,” “That’s easy in theory, but tricky in application”: Yes, agreed, but on which parameters does this depend? What makes it difficult?). For instance, I very much like the definition of a microservice as a piece of functionality with a “bounded context.” But this is never explained in real detail or with real examples to make someone understand this concept from scratch. A really unfortunate omission is the complete neglect of how small or large “micro” really is or should be in “microservice.” Unfortunately, this holds for almost all key terms making up the contents.

The approximately 40 (unnumbered) slides almost exclusively consist of (very simple) high-level noun phrase bullet lists, with the exception of three simple diagrams, which are elaborated and explained (to a certain depth) during the talk. Krause’s manner of speaking is slow and articulated enough to also enable non-native English speaking listeners to understand all of his points.

Having listened to this, you will certainly know many (but certainly not all) buzzwords in the microservices arena. You will also get a superficial impression that this can make sense and would indeed work in practice (maybe with a little bit of adventure to be added as well because of the immaturity of current technology, which the speaker rightfully discloses), but you will not have acquired any real understanding from this talk.