Last January a challenge was posted online by Gunnar Morling: How fast can you parse a file with one billion rows of weather data using Java? Little did I know this deceivingly simple question would lead me down a path that taught me all about: parallelism, memory mapped files, SWAR techniques (SIMD as a register), bit twiddling, branchless code, mechanical sympathy, Graal native compilation and finally... I even turned to the dark side: using sun.misc.Unsafe. Join me in this deep dive where I'll explain all the code changes and tricks that took me from the reference implementation which processes the billion records in less than 4 minutes, to processing everything in under two seconds. Who knew Java could be _this_ fast?

Google's AlphaGo is an extraordinary breakthrough for Artificial Intelligence. The game of 19x19 Go has 1.74×10^172 unique positions and is about a 'googol' times harder to calculate than chess. Experts thought it would take at least another decade before AI would be able to beat the best human players. So how did Google tackle this problem? What algorithms did they use and how do they work?

Arthur C. Clarke once said: "Any sufficiently advanced technology is indistinguishable from magic" The first time I used Shazam (the music matching app) it felt just like that: pure magic. The app shortly listens with the microphone and tells you which song is playing. As a programmer I generally have a pretty good understanding of what happens behind the scenes, in this case, however, we were absolutely gobsmacked. After a weekend of studying, reading scientific papers and experimenting and coding: we had a working Shazam clone written in Java. During this talk, we'll reveal what we've learned and what algorithms and tricks are being used.

We all write unit tests and we measure the quality of the tests with line coverage or (even better) branch coverage... But this is wrong, it gives you a false sense of security. I've seen tests that have 100% coverage but not a single assertion! This is where mutation testing helps out. By creating broken 'mutated' instances of your codebase (mutants) this should result in failing unit tests. This way we can verify that slight code changes (like real life bugs) actually break your tests. In this talk I'll explain what mutation testing is and how you can use it. I'll show and compare some Java frameworks (PIT, Jester, Jumble) that enable (automatic) mutation testing in your project, from local build to continuous integration. After this talk you can and will start using mutation testing!

How do quantum computers work? What is a qubit? What the hell happened to Schrödinger's cats? During this talk we'll together unravel the mysteries of entangled qubits. We'll explain the basics of quantum computing in simple and fun ways, including visual demonstrations with polarsation filters and a skippyball (known as Mr Qubit). We'll even build an actual working quantum computer.... tribute, a simulator, in Java! And I'll explain how larger quantum algorithms work by explaining the quantum benefits in Shor's Prime Factoring algorithm. But beware, this talk isn't for the faint hearted. We'll keep away from all the unnecessary complicated math, but if Math.random() is unlucky we might kill some more cats.

What is software architecture? Is it the decision to adopt microservices? Is it the document that describes the layers in your Java EE application? No, every line of code you commit is part of your evolving architecture. During this talk I'll explain how we, at the Port of Rotterdam, manage our software architecture in an highly agile environment building a successful harbour management system. We spend the last two years transitioning from a modular monolith to a microservice environment. How did our architecture evolve? What is the role of the architect? Do we even need an architect? We'll dive into problems like cargo cult, survivorship bias, shared responsibility, technical debt and system design. In the talk I'll tell about our experiences and the do's and don'ts we've encountered.

Most Java developers have overlooked the Java 9 REPL. This new feature will enable you to make scripts and do live coding with Java using the new 'jshell'. In this talk I'll guide you through the process of building jshell and we'll do live coding to learn how it works and behaves. After this quickie you'll not only be able to build but also use jshell, OpenJDK needs more users to find bugs, make tests and improve this new addition to your JDK9/bin directory.

I've given talks at software conferences about quantum computing and the amazing properties and possibilities of quantum bits (qubits). However: It is now time to give the regular old binary bit the love that it deserves. During this talk we will dive into bits and booleans, the foundation of modern computing and the building block of your entire career. We'll look at truth tables, bit masking, bit twiddling, NAND gates, how to store and manipulate data (like floating point numbers) in binary and finally we'll take a look at the powerful concept of boolean satisfiability & SAT solvers.

Als je ooit Top Gear hebt gezien ben je vast bekend met het fenomeen 'The Cool Wall'. In het TV programma werden auto's besproken en opgehangen op een bord van uncool tot cool en zelfs 'sub zero'. Dit gaat altijd gepaard met veel humor, maar onderliggend toch serieuze punten. Dit concept willen wij tijdens een unconference naar de Java wereld brengen op J-Fall. Jullie, het publiek, helpen mee en samen bouwen we een eigen Java Cool Wall. Als de sessie afgelopen is heb je waarschijnlijk veel gelachen, een hoop nieuwe technieken en frameworks leren kennen en hebben we gezamelijk een J-Fall technologie-radar gemaakt!

Once you get down to a subatomic level, the world around us starts to become very weird indeed. Particles behave like waves and they are seemingly able to time-travel using entanglement. During this keynote we'll explore the wonderful world of quantum mechanics. We'll talk about how these effects can be used in quantum computers, leveraging the power of uncertainty and randomness.

This talk will be filled with failure. Innocent failures, funny failures, small failures, but also failures that took out an entire online banking system for hours. Failures made with a single click and elaborate failures that took months of preparation. There is nothing better than gloating about mistakes and learning from them. Failure often comes at a high cost but during this talk you'll learn from our failures... for free. We have messed up, caused outages and deleted client data so you don't have to. "Learn from the mistakes of others. You can't live long enough to make them all yourself." - Eleanor Roosevelt

How good of a developer are you? Are you a good Java developer? What makes a good developer? And how can we measure this? If you ask Oracle they'll say OCP (Oracle Certified Programmer), which means that you know when the compiler makes those red squiggly lines in your IDE disappear. If you ask FAANG companies it means you can balance a binary tree on a whiteboard. All of these methods involve some knowledge and memory, but have very little to do with actual day-to-day programming, technical skill, problem solving and creativity. And.. don't you think it's annoying you have to take all these technical tests even though you've been coding for many years? In this talk we'll describe our long journey to find a better way to test software development skills; a model based on scientific research, to measure actual coding skills, in a realistic environment. Demo & code included. We're currently working with the (international) Foojay.io community to use these measures and set up a more realistic certification process.