Conference Report #

Basic information #

• Event: goto; Amsterdam 2019
• Location: Amsterdam, The Netherlands (venue was very nice and felt special)
• Dates: 17–20 June 2019 (conference days + masterclasses)
• Audience: Software developers, architects, team leads, and IT people
• Format: Keynotes, parallel talks, sponsor booths, and optional paid masterclasses

Why I went #

This was one of the best conferences I attended up to that point. It matched my interests at the time: backend development, infrastructure, and architecture.

First impressions #

The conference felt very international and well organized. There was always something happening: talks, keynotes, and booths from companies (for example cloud and software-related vendors). Food and drinks were available during the day, which made it easy to stay focused and talk to people between sessions.

It was also my first time in Amsterdam. The city was awesome. It was expensive, but for me it was worth it.

Highlights #

• The speaker lineup was high profile.
• Several talks were recorded, and many of them could be re-watched later online (which is important because many talks happen at the same time).
• The mix of topics was strong: APIs, microservices, Kubernetes, infrastructure as code, security, and some future/vision talks (AI, ethics, quantum, etc.).

Keynotes that stood out #

One of the most memorable moments was the opening keynote by Bruce Dickinson (lead singer of Iron Maiden, but also a businessman and pilot). It was entertaining and different from a typical tech keynote. My notes literally started with: “rocknroll”.

Other keynotes covered big-picture themes like technology trends (for example 5G/AI/IOT), and also lighter topics like “chief happiness officer” style content. Even when a keynote was not directly technical, it was a good change of pace.

After party #

The after party was amazing and a great way to end the day and meet people in a more relaxed setting.

The best part for me was a “coding DJ” set. They showed software where music is created with code (JavaScript), so you could literally see the code and hear the result at the same time. It was a nice mix of tech and fun, and it fit the conference vibe really well.

Notes from talks I attended #

Day 1 #

GraphQL #

• GraphQL “Playground” felt like a client tool similar to Postman.
• Prisma was described as something like a “JPA for GraphQL in TypeScript”.
• The session had some useful parts, but also felt like a bit too much of a sales talk.

RESTful microservices APIs #

• Very good storytelling and practical guidance.
• Topics included stateless services, persistent services, and “aggregator” microservices.
• Strong idea: design APIs for interoperability, not tight integration.
• Mentioned Roy Fielding and the idea “don’t version the API” (at least not in a simple “/v2” way).

Sonic Pi (live coding music) #

• Very fun talk: making music with code.
• The tool is on GitHub and felt accessible.

Practical API design #

• Talked about cost/benefit of API design and how usability matters.
• Mentioned the Kano model.
• API reviews should exist, similar to code reviews.
• Compared styles:
  • REST: conventional and easy to understand (good for external users)
  • GraphQL: can help with flexibility when teams work closely
• A useful question: “How reversible is the decision?” If it is hard to reverse, be more careful.

Kubernetes service migration #

• Motivation: real outages and need for high availability.
• Migration principles:
  • services should not depend on platform details
  • provide sane defaults but keep it open
  • make people want to migrate because of benefits
• Mentioned having redundant clusters for safer upgrades.
• Separating service manifests from Kubernetes-specific parts was an interesting idea.

Spring (functional Kotlin / Spring Fu) #

• Message: annotations can hide logic and make code harder to read.
• Functional routing style was shown as an alternative.
• Spring Fu for Kotlin was mentioned.

Machine Ethics #

• Interesting overview of what is currently possible in AI.
• References included:
  • paperswithcode.com for state-of-the-art tracking
  • mockaroo for data generation

Day 2 #

Micronaut #

• Discussed AOT compilation and annotation processing (code generation).
• Q&A note: Android does not run on a standard JVM (so framework choices matter).

Linux CLI tips #

• Practical command line tricks (cleaning log files, using history and !!).
• Slides were available on GitHub (speaker mentioned “bertjan”).

Prometheus #

• Focus on metrics and monitoring.

REST APIs (process-focused design + coupling) #

• Idea: raise API design from “data endpoints” to “process flow”.
• Mentioned “connascence” as a way to talk about coupling.
• Discussed cost of versioning.
• Suggested using links in responses to present available options in a process (when a link is present, the action is possible).
• Mentioned HAL as a JSON dialect for this style.

API Security #

• Rate limiting patterns (HTTP 429, Retry-After).
• Checking object-level authorization (not only “is user logged in”, but “is user allowed to access this object”).

Day 3 #

Infrastructure as Code #

• Mentioned the State of DevOps Report and the book Accelerate.
• Key idea: strong organizations have both throughput and stability.
• Talked about “monolithic infrastructure” and how big teams can slow change.

Design Sprint #

• Based on Jake Knapp’s work.
• Mentioned menti.com for interactive sessions.
• Good quote-like idea: agility depends on people being willing to learn.

Java 8 and beyond (updating Java) #

• Business arguments for updating:
  • performance (e.g., garbage collection improvements)
  • opportunity cost (hiring and keeping engineers is easier on modern stacks)
  • making future updates easier

Event-driven microservices #

• Discussed command vs event vs query.
• Mentioned bounded context.
• Noted that “location transparency” is required for microservices.
• Mentioned a product called “Submarina” for connecting multiple clusters.

What I liked most #

• Strong focus on real-world architecture and infrastructure topics.
• Many sessions gave practical takeaways I could use at work.
• The overall atmosphere: busy but friendly, and easy to meet people between talks.
• Having recordings available later helped a lot, because I could not attend everything.
• The after party and the coding DJ were a great extra.

What could be improved (small points) #

• Some sessions felt a bit sales-oriented (for example parts of the GraphQL/Prisma content).
• The schedule had many parallel talks, so you must choose and will miss things (but recordings help).

Conclusion #

goto; Amsterdam 2019 was a great experience for me. The combination of keynotes, deep technical talks, and the conference atmosphere made it one of my favorite conferences at the time. It was expensive, but I felt it was worth it because I learned a lot and also enjoyed my first time in Amsterdam.

If you are interested in backend, infrastructure, APIs, and modern architecture, this conference is a very good option.