at GOTO Amsterdam 2020

Good Old Plain Programming

GOTO Amsterdam 2020 will gather the pioneers and game-changing coders who shape our industry and radically improve the way we look at software.

For our 10-year anniversary, we’re taking things back to basics: good old plain programming. We’ll dive into core technical concepts and explore what quality code looks like in 2020 and beyond.

Whatever you’re working with — frontend, backend, mobile, cloud services, microservices, events, machine learning, maybe even upcoming technologies like quantum computing — it’s all based on solid fundamentals like programming languages, testing skills, scalability, stability and a focus on the end user.

Each keynote, session and masterclass is designed to deliver a blend of eye-opening ideas and the practical skills needed to write software you can be proud of.

Cloud Native

Cloud Native means building apps designed specifically to leverage cloud computing, often defined as container-packaged, dynamically managed and microservices-oriented. This architectural pattern allows systems to be self-healing, auto-scaling and highly available.

Organizations can radically reduce costs leveraging the efficiency of cloud computing when using Cloud Native technologies.
But which problems will adopting Cloud Native solutions actually solve?
Where do we start and how can we best strategize for a successful Cloud Native journey?


Testing is an increasingly integral part of how development teams deliver software. Gone are the days of outsourcing testing and quality assurance to some other person, team or department. With the adoption of microservices-based architectures and continuous integration processes, many tests can, and in fact should, be automated.

But testing automation doesn’t spell the end traditional testing methods such as end-to-end or exploratory testing. In fact, with modern architectures running in the cloud, new ways of testing have emerged, such as canary testing, resilience testing and chaos engineering. For the modern development team, delivering secure, relatively bug-free software with the features users want requires an integrated, collaborative and robust approach to all levels of testing.


Choosing a programming language is one of the most crucial decision when developing software - the choice can influence the way you and your team think about your problem domain and how you model it.

It can also be overwhelming, daunting or even impossible to understand all of the new backend programming languages coming up - almost as frequently as new JavaScript frameworks.
Is this new language just hype, or will it actually help our team to be more productive?

As developers, we need to be aware of the languages topping the hype curve and focus on the production-ready ones that provide real functionality. We also need to understand the exciting updates to older languages like Java and how ones like C++ are still incredibly important in a newer era.

The Human Factor

We live in a time where the hierarchical structure of teams with managers is moving to a new model of tribes with leaders. In the ideal version of this new landscape, the expertise of developers and specialists is recognized and everyone is involved in the decision-making process.
How can we make this transition?
How do we cope with our new roles?
What works and what doesn’t?

Behind every online interaction is a real live person with their own unique background, perspectives, biases and context. To be successful we must embrace and nurture our relationships with other humans, whether they are community members in an open source project, founded start-up or work for a huge corporation.

Quantum Computing

50 years ago, quantum computing was just a theory. Today, quantum programming is getting close to becoming the new reality for software developers.

Quantum computers have the potential for disrupting how we fundamentally store, process and utilize data and could provide significant breakthroughs in the optimization of complex systems, artificial intelligence and many other areas. Universities around the world are investing heavilty in quantum computer research. Companies like Google, IBM, Microsoft and Rigetti Computing are making it possible for the rest of us to actually leverage quantum processors in the cloud.

So, how we can we, as developers, get started with quantum programming? And what kinds of problems will quantum computers actually solve?

Machine Learning

Automation has improved productivity across entire sectors. Software has driven much of this automation, but many workflows still require decisions by humans.

The promise of machine learning is to automate the decision-making process by training algorithms, based on empirical evidence. That promise is becoming very real and tangible for developers who are now able to leverage massive amounts of data with cloud computing power via learning libraries like TensorFlow and frameworks like MXNet.

How can today's engineers take advantage of modern learning methods?
What are the main ideas and pitfalls when trying to automate decisions?
How can organizations harness the power of machine learning to power their business?


You’re using containers and CI/CD pipelines so you’re done right? Wrong!

DevOps promises to deliver better software quicker with shorter development cycles, increased deployment frequency, and more dependable releases. The Three Ways of DevOps - systems thinking, amplifying feedback loops and creating a culture of continual experimentation and learning - provide a solid framework but DevOps is more than just tools and techniques. You can’t simply buy it or adopt it and without significant culture shift, you can’t just hire it.

If you build it, you run it - but which skills and tools do you actually need to make the transition and run DevOps successfully?
And how do we incorporate emerging ideas like Cloud Native, Serverless and Chaos Engineering as the next steps to enable more rapid iteration and better cooperation?


Microservices promise faster development, deployments, scaling and all the goodies you always wanted but never had. It’s all about outcomes and the way your organisation is structured has a tremendous impact on those outcomes. It’s easy to say “Conway’s Law” and then move swiftly on but that’s not enough. Yes, a core characteristic of organizations successfully running microservices is that teams are organized around business capabilities but there is so much more to discuss:
How do we define a microservice?
What does a microservices architecture require?
How do we withhold or even increase you current level of security when moving to a fine-grained distributed architecture?

But microservices themselves are the easy part. The really difficult choices revolve around everything that surrounds the microservices systems as they are designed, built, run, managed, evolved, stressed and even retired in production. We must consider how to manage and optimize the processes, practices, people and technologies when migrating from a monolithic system to a Microservice Architecture.


Serverless will revolutionize the way we write backend.

As a natural next step from Cloud's "Not on my machine" mantra, serverless applications offer more cost savings over bare-metal solutions through improved optimization of infrastructure resources.
But how do we actually build serverless apps and run them successfully in production?

Security & Ethical Hacking

On average, it takes a company 8 months to figure out it has been hacked. In a world where innovation and deployment is expected at an ever-increasing pace, security is often neglected. Security requires time, and this time is often not prioritized imposing a challenge when new vulnerabilities are discovered and exposed every day.

As developers, how do we build inherently secure and maintainable code and infrastructure to protect our data and identities?
How do we equip ourselves with tools to withstand intrusive and adversarial attacks and prepare for unforeseen security risks?

Organized by