What Lies Beneath

Did you ever asked yourself a question: What really happens when your Java program runs? After the transformation from Java source through bytecode and machine code to microcode, and the various optimizations that take place along the way, the instructions that are actually executed may be very different from what you imagined when you wrote the program. This session shows you tools and techniques for tracing that path. You’ll see what a simple program actually looks like when it really hits the hardware.

Jenkins Configuration as Code - Automate your automation Server

Jenkins Configuration as Code (https://github.com/jenkinsci/configuration-as-code-plugin) is an open source Jenkins plugin that will allow users to keep complete Jenkins configuration in simple configuration file (yaml format). In the talk I'll briefly present the history behind the plugin, the vision for the future and current status. Then I'll move to demo section where I'll show how easy it is to configure and run Jenkins with the help of the plugin. I will end with short guide for open source enthusiast that would like to contribute to the plugin. The target audience for this talk are Jenkins daily users or administrators but also Java Developers - beginner level is enough - that would like to start to contribute to open source projects.

Understanding Low Latency JVM GCs

Since several years, the world of JVM GC evolved. A new kind of GC emerges: low latency GCs. Shenandoah is provided by Red Hat, Oracle open sourced ZGC in OpenJDK since JDK 11 and Azul C4 is sill there.​ As 'classical' GCs are well understood, this talk will focus on internals of the most recent ones. We will explain Concurrent Marking (tri-color marking), the C4's Load Value Barrier, Shenandoah's Brooks Pointers and ZGC's multi-mapping. Finally, how to choose a low latency GC?​

Enough java.lang.String to Hang Ourselves...

Is it better to write '' + 42 or Integer.toString(42)? How much memory can you save if you intern() all your strings? How can String Deduplication reduce your memory footprint, and what does it cost? And how much memory will Java 9 strings save in Bulgaria? What is the maximum length of a constant string? And a dynamic string? How much faster is the new StringBuilder().append('Hello ').append(name).toString() than 'Hello ' + name? What are intrinsics, and how do they relate to strings? Are strings really immutable? How can you efficiently create substrings? You’ll get answers to these and many more questions in this session.

Common mistakes when moving to microservices

While helping organizations move to microservices and public clouds, I’ve noticed a lot of common problems. Architecture is described at infrastructure level (k8s, cloud services, etc.) without any focus on domain architecture. Enterprise architects are put in charge of software architecture. Architecture guilds are created without introducing the required practices and culture. QA still thinks that end to end tests are possible. Managers want to sign-off and control deployments. Pipelines and processes are forced on devs, not allowing them to become devops (the culture doesn’t change). Devs do not learn the different flavors of event based architecture, relying on REST everywhere. Kafka is treated as a message queue (no streaming, no read models, no persistence). Half-baked tools provided as a service by the cloud are assumed to be cheaper/safer to use than self-hosted open source. Teams are created without repo ownership, creating an error prone setup. Finally business pivots are not taken into account, when designing the system. I’ll discuss all those problems, and hopefully provide some usable solutions.

Developer's guide to selling your soul

In almost every developer's life there comes a time at which he/she has to choose. To go into management, or to stay in development. Now, if you're a 'my concept of fun is reading about monads and category theory' kind of developer, this will probably feel like you're selling your soul to 'The Man'. But here's the hard truth. No matter what you want to achieve in your professional life, chances are you'll need help from other people to do that. So doing at least some sort of management is not an option, it's a necessity. In this talk, I'll tell you about my experience of going through this transformation. I'll try to sum up my ups and downs into a quick and easy cookbook you can use in your day-to-day operations. So that you still have time to do what you love the most, develop!

Implementing Webhook backends, not so trivial

Webhooks, we know what they are, right? You’ve probably already used some to be notified of Github commits, to react to text messages received via Twilio, or created a fulfillment for a Dialogflow chatbot to answer users. From the Webhook consumer side, it doesn’t seem complicated to code… On the server-side, is it really just a web API to implement? Hmm… maybe not! Actually, we’ll see that it might be not as simple as it first sounds ! After an introduction on the concept of Webhooks, we’ll create our own callbacks to be notified of events. Then, we’ll go on the other side of the mirror, by creating our own Webhook backend. We’ll study how to deal with client subscription queues, manage all kinds of errors, debug the webhook, handle retries to avoid flooding subscribers, or how to secure those hooks. There’s lots to cover!

How and why we turned our old Java projects into first-class serverless components

These days rule and workflow engines are often overlooked, possibly because people think that they are only useful inside heavyweight enterprise software products. However, this is not necessarily true. Simply put, a rule engine is just a piece of software that allows you to separate domain and business-specific constraint from the main application flow. Similarly a workflow engine allows you to put higher level abstraction (not always in graphical representation) over your logic, yet keeping you focused on actual business goal. We are the project leads of Drools and jBPM, respectively the rule and workflow engine of Red Hat, and our target was to modernize our projects and make them ready to be used in serverless environments. In this talk we will explore and make sense of technologies like GraalVM and Quarkus. In particular we will show, with very practical use cases like ours, what is necessary to change in a code base making extensive use of reflection, dynamic class loading and other Java sorceries in order to make it compatible with those technologies and demonstrate how this is allowing us to make Drools and jBPM part of the cloud and serverless revolution.

Designing APIs for Polyglot World

The world has changed since I published the Practical API Design book. The JVM ecosystem now supports variety of other languages - be it Scala or Kotlin & co. Moreover a completely new tree of dynamic languages (JavaScript, Python) has meanwhile flowered into at first sight independent ecosystem of its own. Do the API design advises still apply? They (mostly) do. However rather than showing how to apply them to each different language one by one, let's try something more advanced. Let's design a single Polyglot API that works for all of them! This session will show how to take an existing Java API and add polyglot flavor to it. We show how to use that new polyglot API from JavaScript, Python, etc. We demonstrate how (surprisingly) fast and efficient such execution can be. If you have your own Object Oriented database or just pile of BigData to process efficiently by any programming language, stop by. We'll show you how to process such data fast!

Purely Dysfunctional Data Structures

The design of performant immutable data structures is a challenge that was accepted by Chris Okasaki over 20 years ago. In this talk, we’ll explore what the concept of Persistent Data Structures is, how are they implemented, and how much blood, sweat, and tears need to be done on the other side to make the experience of working with immutable data structures efficient.

Reactive features of MicroProfile you need to learn

Why reactive? How is MicroProfile related to reactive programming? There are many reactive Java libraries but they all work in a different way and provide different API. MicroProfile brings common reactive APIs that can be reused in many libraries to provide a unified experience for many Java developers. Including reactive operators, messaging, REST and more. The core MicroProfile reactive operators API is designed with care by experts behind popular reactive libraries. MicroProfile also provides reactive APIs for asynchronous messaging, REST and thread-control, as well as interceptors to improve the fault-tolerance of your applications. On top of that, MicroProfile aspires to bring unified reactive APIs to Jakarta EE and even to Java SE to make them more accessible to every Java developer. Learning MicroProfile API once will make it easier to get you started with many reactive frameworks with less additional learning.

Pyramid of Refactoring

Everyone has heard about test pyramid… and refactoring pyramid is its twin. Using Pyramid of testing we can set up the tests coverage of the existing functionality reaching given level (UI, modules, packages, classes, methods). This allows us to have a look at corresponding pyramid of refactoring and figure out what kind of refactorings can be performed safely. We start from the bottom of testing pyramid (simpler conditions, smaller methods) and climb up towards the highest level that is covered by tests. This concept will be presented using live refactoring of simple logic into interpreter design patterns. This way we will experience that refactoring at higher levels (design patterns, classes) can be continued only once lower levels like small methods, small classes, interfaces are being taken care of. You need to experience to understand.

Service Mesh patterns

As we start to go toward cloud-native infrastructure and build our applications out of microservices, we must fully face the drawbacks and challenges to doing so. Some of these challenges include how to consistently monitor and collect statistics, tracing, and another telemetry, how to add resiliency in the face of unexpected failure, how to do powerful feature routing (ie feature graduation, tap compare ) and much more like securing your services correctly. Service mesh, in general, helps developers solve this in a non-invasive way. In this session, we'll show how you can take advantage of these capabilities and show you some patterns that you can implement easily with a service mesh to make your delivery to production smoothly and without surprises. We expect most developers haven't adequately solved for these issues, so we'll take it to step by step and build up a strong understanding of Istio and its patterns, harness its power in your production services architecture.

Not dead yet - Java on Desktop

Interestingly a lot of people say Java on desktop is dead and yes it is not in the hyped zone anymore. But on the other hand it is still widely used. This session will try to give an overview on Java on desktop and why it is not dead yet. I will give examples for scenarios where Java on desktop really shines and others where you better choose a web application. It will also show the state of JavaFX with all it's different flavours like standard JavaFX on desktop, on embedded, on mobile using Gluon and on the web using JPro. And of course there will be demos for those different scenarios.

Live exploiting your open source dependencies

Today, almost all software heavily relies on the use of third-party dependencies. While open-source modules are undoubtedly awesome, they also represent an undeniable and massive risk. You’re introducing someone else’s code into your system, often with little or no scrutiny. Including the wrong package can introduce severe vulnerabilities, exposing your application and your user’s data. We’ll look at examples in the wild that have been exposed, some more famously than others, before showing you how to guard against these important security issues.

How to survive as a Team leader

The story is very common. When you are a good (or excellent) developer, sooner or later (you can bet sooner) someone comes and asks you to try a “better role” – a team leader. The logic is clear. If you can manage thousands of complicated lines of code, algorithms and insane tasks, how could ever two more people harm you, right? Things that seem challenging and interesting from the career perspective at first very often end with depressions, burnout, etc. In this speech, we would like to address ten key characteristics that make a good leader and also help to identify the bad ones. We will also provide basic tips and tricks on how to survive long enough to identify, whether the new role is the right one or it is time to become a good (or excellent) programmer again. Agenda of the speech:

Being transactional in 2019 - what does it actually mean?

When I was young and took my CS classes I learned about ACID and it seemed sound and reasonable. Then I went to work and learned that it could mean different things (especially isolation…) for different database vendors… Around 2009 I’ve heard about CAP theorem - that was also sound and quite reasonable in the brave, new distributed world. And then one after another - NoSQL vendors started to claim they’ve beaten CAP theorem (* as they understand it of course…) And recently it got even more complex - stream processing engine have their notion of transactions - atomicity, isolation and so on. In this talk I will try to make something out of this mess - we’ll look at some of definitions and try to figure out which use case require particular kind of isolation or transactionality. Of course some of it will be based on my own experience - including quite a lot of blood, sweat and tears ;)

An introduction to JHipster

JHipster is today's most popular code generator in the Java world, with more than 2 millions installations, 500+ contributors, and thousands of companies using it. It allows to build a wide range of applications, from small microservices to full-stack applications, with a strong focus on code quality and developer productivity. In this introductory talk by the lead developer of the project, we'll live-code a sample application and showcase the most interesting highlights of JHipster, starting with an empty folder and deploying the finished application to production.

Who ate my RAM

Java, the runtime, likes memory. And it is also a fact well known to those who know it well, that subtle differences in code, result in drastic changes to applications memory and runtime profiles. I'll take you through the memory lane part of my work, and show how do I approach analysis, problems and troubleshooting. Tools, what information can they surface, and how to navigate back to the code. Techniques and libraries, how do they affect what the application does. Feel invited if you believe troubleshooting memory in Java is 'magic', or 'only tuning the GC can save us'.

Coding Your Way to Java 13

It seems like keeping up to date with Java nowadays can be a daunting task. Gone is the era of big, delayed Java releases that span years. We’re now getting a new major release every six months. What’s up with that? You’re probably still developing on Java 8, even though Java 13 is almost released already. Attend this session to get a code-first overview of what’s new in Java since Java 8. You’ll get an overview of the module system (Java 9), the local variable type inference feature (Java 10), and the new HttpClient API (Java 11), plus a sneak peek of Java 12 and 13 preview features. It’s time to embrace the newfound agility of the Java platform!

From Developer to Manager... and Back

Would you like to become a team leader or a manager some day? Or maybe you already are one? I was a manager. Yes, I was, because I am not anymore. And I would like to tell you my story: How did it happen that I became a manager? What difficulties did I encounter? How did I tackle them? What have I learnt? Why did I go back to being a developer? I will also present a little bit of theory around management and I will share some of my own observations with you. All of this with a jot of humour, which will (hopefully) be a strawberry on top. See you there!

Micro Frontends – a strive for fully verticalized systems

We’ve seen significant benefits from choosing a microservice architecture for building enterprise applications, which allows us to structure teams based on business capabilities, improve scalability and enable the flexibility of being polyglot in the usage of technologies. Mostly this architecture is then complemented by a feature-rich and powerful browser application which sits on top of these backend-services. Unfortunately, the latter step ends up way too often in the creation of a single, sprawling and hard to maintain frontend-monolith. The approach of micro frontends is an effective way to tackle this problem and first appeared at the end of 2016 on the ThoughtWorks Technology Radar. By going into detail about the underlying concepts of this architectural style, the idea of extending concepts of microservices to the frontend world, the importance of fully end-to-end verticalized systems, and the difference of an orchestration- or choreography-based implementation become reasonable. Upon a closer look at the advantages and challenges I've experienced in customer projects, it turns out that micro frontends are not a silver bullet either. Rather, they are suited for a specific set of problems. In a nutshell, micro frontends can be a powerful tool to avoid frontend monoliths and this talk will give you the needed knowledge to decide if it’s the right one for the job.

5 elements to grow software architecture

Martin Osovský, Chief Product Architect at Y Soft, will touch upon five of the most important elements to do software architecture regardless of your development environment and product. In particular, he will discuss structure, vision, validation, all the fun and soft skills involved, patterns, principles, rules, and tradeoffs.

Kotlin Native 101

Can you create native apps with Kotlin? Yes, you can! Kotlin Native allows you to do just that. But if you used Kotlin on JVM then you'll find quite a few surprises when going native. You'll encounter a different concurrency model. You'll see that memory management is also changed. You'll have to find a way to interoperate with some C/Objective-C code to do something useful. In this talk we'll go for a tour of Kotlin Native features, which in the end allow you to create safe, robust native applications for a plethora of platforms: Linux (even on Raspberry Pi!), MacOS, iOS, WebAssembly and even some embedded systems.

Escaping The Jar Hell With Jigsaw Layers

Jigsaw modules are often criticized for the lack of versioning that exists in alternative module systems for Java, such as OSGi. One of the main purposes of versioning is to solve the so called Jar Hell problem that arises when your application depends on two different versions of the same library. While Jigsaw is able to detect this conflicting situation, it won’t allow you to load both versions that are placed on the module path. However, it is not always possible to eliminate all version conflicts from your application, because other versions of the same libraries can come to your application indirectly via dependencies that you do not control. Fortunately, there is a native solution for the problem in Jigsaw called Layers. In this session, I will show what problems Jigsaw could have introduced if it had explicit versions for modules, and how Jigsaw Layers in conjunction with Jigsaw Services help to solve the Jar Hell problem safely.

A different flavor of the distributed transaction

Transactions are one of the most complex and yet very important areas of computing. They can get particularly hard when the system moves to the distributed environments as almost every component in the distributed system is liable to failures. Traditional locking protocols, used in transaction solutions today, are then very prone to holding locks on resources for unnecessarily long periods. The saga pattern provides an alternative non-blocking solution with the design that allows individual parts of the transaction to commited immediately and independently. This design is specifically suitable for long running transactions and distributed systems. In this session, we will present a newly created MicroProfile specification called Long Running Actions (LRA) which provides a definition of the transactional protocol and a simple API for the distributed transactions in the Java microservices environment based on the saga pattern. We will show you why the saga pattern is a very suitable transactional solution for many distributed microservices applications and demonstrate the usage o the LRA specification with the live coded demo.

IoT Edge to the rescue

The world is moving from processing the data in the Cloud to processing it on the Edge devices. Edge computing helps to break beyond the limitations imposed by, now, traditional cloud solutions. There are a few reasons to that, like privacy concerns, reducing the need for heavy processing resources, reducing the amount of data that is sent over the network – just to mention a few. In this talk, we will introduce the concept and benefits of Edge Computing, how such devices can be built using affordable hardware and we will look at examples on how IoT Edge devices are in practice as well as comparing Edge Computing with other options. As a demo, we have automated the manual job of counting the attendance for talks at one of the rooms at a conference. We have built a live system while keeping the privacy of the people intact; without leaking faces and identity of the people to a 3rd party or Cloud providers. In addition to standard video processing, we added advanced ML techniques and models to the device to demonstrate the power and flexibility of the Edge devices nowadays.

The Future of Java is Now: deep dive

The Java platform experiences an outburst of cool new features – recently, local variable type inference, switch enhancements and multi-line string literals have been added to the Java language. Many other features are being in the pipeline and are actively worked on, like simple data carriers and pattern matching for the Java language, or value types for the Java virtual machine. These features are delivered quickly, thanks to the recently adopted, predictable, six-months schedule of major Java SE releases. This new release cadence means new Java platform features are delivered twice every year! In this talk, we will show a live demo of many of the recently added and newly developed features and improvements for the Java platform, including those mentioned above.

Back to basics: threads

When was the last time you run any production code on single-core CPU? And even if, was it a single-threaded code? We shield ourselves from threads with layers of abstractions that promise to take care of everything. However it is often impossible to talk about the application without understanding the underlying thread model. During this talk i would like to get back to basics. Where does the JVM take threads from? How much a thread cost? How do the threads interact and is my CPU any different from distributed system? Why do we create thread pools and how to control them? How many (and what) threads are there in typical app? You will find answers to those questions on my presentation.

From Java Monolith to K8s: Lessons learned in an Open Source project

I was in charge of migrating a monolithic open-source large application written Java to a cloud-native approach running smoothly on Kubernetes. To fully take advantage of the new environment, the architecture was completely redesigned. In this session, I will cover my lessons-learned from that exciting/painful experience and give you some guidance on what going cloud-native could mean for you. I will cover tools around the K8S ecosystem that will help you to sail smoothly to your destination port. A live demo on how it feels to bring an application to Kubernetes – with a hint to the typical pitfalls will be presented.

Chaos Development: Removing software as the inhibitor of Agile

You’re starting a new project. You’re using real Agile (finally!). Kickoffs, initial stories, tool selection… the atmosphere is electric. That first iteration is complete; yes, a few kinks, but we’re rolling now. A couple of more iterations flow by before the euphemism “technical debt” is heard. The next couple of iterations are a bit of a struggle. Finally, it looks like the goals may not be achievable. Programmers mumble about faulty designs and changing requirements. Business owners roll their eyes, thinking, “Here we go again…”. What happened? Practical Agile practices were followed, but were mated with very traditional, inflexible programming styles. Agile development centers around accommodating change. Stories can be played in business-friendly order. Unanticipated changes can and should be accepted with aplomb. Therefore the design and implementation of the software must also accommodate the uncertain. Chaos engineering is the vogue term used to describe the design of systems that handle the unexpected. Similarly, software development must accommodate unexpected demands. It needs to focus on chaos development. In this presentation, we will suggest two distinct approaches to chaos development. The first exploits existing OO languages, but employs a particular style of programming, and can be used for most business problems. The second uses an event bus and highly decoupled services, a technique called asynchronous MicroServices, and is appropriate for addressing fuzzy problems. For the first style, we will delve into the aspects of the style, particularly its focus on small, tight classes; extensive exploitation of design patterns; and careful monitoring of complexity metrics. For the second style, we will briefly address the principles at work, and show a brief animation of the type of problem nicely handled by asynchronous MicroServices.

The Future of Java is Now

What’s new in Java today, and what’s coming to Java tomorrow? This talk will review some of the recent enhancements made to the language and the platform, as well as offer a glimpse into some of the features in development that will continue to improve both developer productivity and program performance while retaining Java’s core values of readability, generality, and compatibility.

Yamlware and the state machine

Yaml FTW! Infrastructure as code is eating the world (well, part of it). YAML, JSON, TOML, HCL and several other languages tend to describe the desired state of your infrastructure controlled by the STATE MACHINE. How does it work? Let’s dive into an illustrated journey behind the machinery of various tools like Terraform, Ansible, Kubernetes.

Spring Framework 5.2: Core Container Revisited

Spring Framework 5.2 takes Spring 5's common themes to the next level: embracing new reactive technologies such as R2DBC and RSocket through Spring's transaction and messaging abstractions, and revisiting the core component container for GraalVM support and compile-time annotation indexing. This talk focuses on core facilities for optimized application architectures in modern deployment environments, with support for Java as well as Kotlin, as a foundation for higher-level features in Spring Data and Spring Boot.

Kotlin: 102 - beyond the basics

This talk is about covering language aspects and idioms that you usually don’t see in a 101 talk. Among other things we'll understand covariance and contravariance with generics, learn about the secrets of inline functions in Kotlin and how combining them with reified generics we can work around type erasure on the JVM. We'll dive into lazy evaluation with sequences, use delegation to leverage code reuse and understand lambdas with receivers better to create our own DSL's. Finally, we'll dive into co-routines and see how this powerful concept allows us to deal with concurrency and asynchronous programming, and its difference to languages such as C# or Java.

Welcome to the Machine (in room 9)

Information is everywhere and for many people, especially in the connected world, it is accessible freely or at a minimal cost. News outlets rely on social media to broadcast breaking news. Social media in turn relies on us to feed it with information, be it of our surroundings or our personal information. It’s become somewhat of a self-sustaining self-serving machine in which we’re all part of. It’s big data and we’re a cog in the wheel. For now of course, because with big data and cheap yet powerful hardware, AI also wants to play the game. And if information and knowledge is the key to success, surely this means we’re on the right path. The question is, will we notice some of the warning signs before it’s too late…

Extending Cloud/Desktop IDEs, providing a new choice for developers.

Developers, using several programming languages at work, have a choice of IDE and can have the same language support because of new standards like the Language Server Protocol (LSP, https://microsoft.github.io/language-server-protocol/ ) and Debug Adapter Protocol (DAP, https://microsoft.github.io/debug-adapter-protocol/). The majority of modern IDEs implement support for those protocols giving developers freedom to switch between languages or IDEs, Cloud or Desktop IDEs, or extend or build their own flavors of IDEs using frameworks like Eclipse Theia ( https://www.theia-ide.org/, https://github.com/theia-ide/theia ). Our team of developers build DevOps tools for mainframe developers who often need to work with Java, High-Level Assembler, Cobol or even TypeScript to support enterprise applications running in mission-critical infrastructure spread from mainframe to distributed systems. Our goal is to provide a choice of tools for developers and let them learn technologies, adapt to business faster and enjoy their work in such environment . In cooperation with several open-source communities like Eclipse Che ( https://projects.eclipse.org/projects/ecd.che ) , Eclipse Theia supported by RedHat, IBM, TypeFox, CA Technologies a Broadcom company and others we extend Eclipse Che and Theia platforms with our own implementation of LSP, DAP https://projects.eclipse.org/proposals/eclipse-che4z . We also use several languages in our own development, TypeScript for development of Explorer for z/OS https://github.com/eclipse/che-che4z-explorer-for-zos or Java for development of LSP for COBOL https://github.com/eclipse/che-che4z-lsp-for-cobol. Freedom for developer can look like this video https://www.youtube.com/watch?v=zcZaOlb98Ec&feature=youtu.be. This presentation is to share our experience with designing and building solution on cloud based IDE. We are going to review a set of cutting edge technologies developers may use to create platform agnostic solutions.

Let's chat about chatbots

In the last couple of years, the popularity of messaging apps has grown rapidly. Because of that fact, chatbots, computer algorithms with the ability to communicate with people in their natural language, became a big thing as well. Nowadays, one can talk to chatbots in a variety of websites, messenger, WhatsApp, Skype, and others. There are a lot of applications where chatbots can be valuable: customer service, handling minor daily tasks, updates and content delivery, e-commerce bots, event reservations, agenda/scheduling, virtual assistants, project management, data gathering, and analysis. One of the most important questions that can be asked considering this topic is: how does chatbot actually work? There are two general types: those that use pattern matching (simpler to implement, usually use the combination of if-else statements and basic statistics), and Natural Language Processing (NLP) with Natural Language Understanding (NLU) based algorithms, but only the latter type can be really considered as an artificial intelligence due to its complexity. NLP is mostly used for text analysis purposes such as Information Retrieval, Information Extraction or Text Mining. To actually achieve those goals, some necessary steps need to be followed: tokenization, syntax analysis, semantic analysis, discourse analysis, and pragmatic analysis. All of them will be discussed during the presentation for beginners.

Reactive Spring

Microservices and big-data increasingly confront us with the limitations of traditional input/output. In traditional IO, work that is IO-bound dominates threads. This wouldn't be such a big deal if we could add more threads cheaply, but threads are expensive on the JVM, and most other platforms. Even if threads were cheap and infinitely scalable, we'd still be confronted with the faulty nature of networks. Things break, and they often do so in subtle, but non-exceptional ways. Traditional approaches to integration bury the faulty nature of networks behind overly simplifying abstractions. We need something better. Spring Framework 5 is here ! It introduces the Spring developer to a growing world of support for reactive programming across the Spring portfolio, starting with a new Netty-based web runtime, component model and module called Spring WebFlux, and then continuing to Spring Data Kay, Spring Security 5.0, Spring Boot 2.0 and Spring Cloud Finchley. Sure, it sounds like a lot, but don't worry! Join me, your guide, Spring developer advocate Josh Long, and we'll explore the wacky, wonderful world of Reactive Spring together.

Inspired to Code (in room 9)

Programming is not considered a dangerous occupation. We sit in a comfortable chair all day, typing away at the keyboard. Besides a bit of wrist tendonitis and back pain, how bad can this be? '... much study wearies the body' - King Solomon. It is physically exhausting when we think all day long. What's worse, the stress does not get a chance to escape from our body. Then our inactivity affects our sleep. And to make matters worse, companies tempt us with lo w quality sugary foods like donuts and packet chips. In this talk Heinz will share from his life, how his journey is ta king him towards better health. Tips like prioritizing sleep. Gadgets that will help measure our progress. (Geeks love gadgets.) Also some interesting Java puzzles to engage the brain.

Let's Play!

ML and AI technologies are a great tool to automate various business processes. In this short presentation I will try to automate something significant, something which usually takes long hours, may ruin health, lead to sleep deprivation, may even break up families... we will try to teach computers play games so we won't have to. How to translate game play problem into language of ML algorithms? I will explore possible solutions from the simplest manually crafted algorithm through classical supervised learning methods to end up with reinforcement learning based approaches. This presentation may contain asteroids, spaceships, laser guns and a significant portion of poor Python code.

Reflection-Free Applications with Micronaut

Micronaut is a new framework designed for creating lightweight microservices with focus on the minimal memory footprint and deployment size. It is probably the only framework where GraalVM is a first-class citizen from day zero. Micronaut dependency injection mechanism is a reflection-free and proxy-free alternative to Spring. Let's take a look on new addition into the Micronaut's reflection-free ecosystem - Micronaut Data, native bean validation, bean introspection, new Jackson deserialization module. Micronaut provides compile-time dependency injection to minimize the memory overhead known from Spring. As it was created by the Grails team, Micronaut comes with easy to use the command-line interface. Java, Groovy and Kotlin languages are supported. Thanks to minimal startup time, you can deploy new instance in less than a second and you don't need any special infrastructure for you integration tests - you just spin up an embedded server and you are ready to go. Micronaut is a perfect fit for serverless functions such as AWS Lambda.

Building cloud-native microservices with project Helidon

MicroProfile is a collection of Java APIs and technologies for developing microservices portable across multiple runtimes. Project Helidon is a high-efficient modern MicroProfile implementation plus a reactive 'zero-magic' functional style APIs, GraalVM integration, gRPC support and other cool features. Come to this sesion to learn about project Helidon. As part of the presentation we will live-code a full featured microservice; demonstrate usage of configuration, health check, metrics and tracing; and deploy it to Kubernetes.

Developer's guide to selling your soul (lightning talk)

Reflection-Free Applications with Micronaut (lightning talk)

In almost every developer's life there comes a time at which he/she has to choose. To go into management, or to stay in development. Now, if you're a 'my concept of fun is reading about monads and category theory' kind of developer, this will probably feel like you're selling your soul to 'The Man'. But here's the hard truth. No matter what you want to achieve in your professional life, chances are you'll need help from other people to do that. So doing at least some sort of management is not an option, it's a necessity. In this talk, I'll tell you about my experience of going through this transformation. I'll try to sum up my ups and downs into a quick and easy cookbook you can use in your day-to-day operations. So that you still have time to do what you love the most, develop!

Micronaut is a new framework designed for creating lightweight microservices with focus on the minimal memory footprint and deployment size. It is probably the only framework where GraalVM is a first-class citizen from day zero. Micronaut dependency injection mechanism is a reflection-free and proxy-free alternative to Spring. Let's take a look on new addition into the Micronaut's reflection-free ecosystem - Micronaut Data, native bean validation, bean introspection, new Jackson deserialization module. Micronaut provides compile-time dependency injection to minimize the memory overhead known from Spring. As it was created by the Grails team, Micronaut comes with easy to use the command-line interface. Java, Groovy and Kotlin languages are supported. Thanks to minimal startup time, you can deploy new instance in less than a second and you don't need any special infrastructure for you integration tests - you just spin up an embedded server and you are ready to go. Micronaut is a perfect fit for serverless functions such as AWS Lambda.

Lunch - room 3 (VEGE)

Penne with sundried tomatoes, garlic, olive oil and rucola with corregio cheese salad

Lunch - room 5

Chicken filet with sundried tomatoes in red pesto sauce + rice + salad

Lunch - room 7 (Gluten free)

Beef bourguignon + bunkwheat with vegies + salad

Lunch - room 3 (VEGE)

Dumplings: Spinach & feta + Russian with salad

Lunch - room 5

Pork Vietnamese + jasmine rice + salad

Lunch - room 7

Turkey in thyme sauce + pearl barley with vegies + salad

Lunch

Lunch time!

Registration & breakfast

Breakfast

Break

The best time to take coffee or juice

Coffee Break

The best time to talk with speakers and attendees

Lunch Break

Keynote

Opening ceremony (in room 9)

Closing ceremony (in room 9)

TBA

To Be Announced

Lighting talk TBA

Lighting talk - To Be Announced

Topic tables

Join other attendees and share ideas, talk about the recent challenges, or find solution for a problem. During this session you can connect with other like-minded people in a space designated for certain languages, technologies, and interests.
1. Suggest a topic
Look for large white sheets of paper, and tell everyone what is on your mind! You can also tweet using #topicforgeecon hashtag. Vote for topics (mark it with line/x/heart) and like tweets to show others you’re interested.
2. Choose a room and have fun
We will group similar topics and assign a room. Topics will be pinned before room entrance (list of topics and rooms will be also posted using attendees slack channel - slack.geecon.cz), so you will be able to join others also interested in eg. Kotlin, JVM tuning, Machine learning or testability.

Party + Open Spaces @La Republica, Na Poříčí 12 Street

Party

Party time!