Tactics and strategies on software development: how to reach a successful software

Being pragmatic and understanding the tasks are crucial for effectively achieving your activity as a software developer. Unfurtenelly more is needed to acquire successful software. At this point, you need to go beyond and understand the strategy and tactics of the software engineer. Good software is closer to business and needs to be ready to change often. Rewriting the whole system from scratch becomes a real temptation. New shiny solutions like microservices pretend to solve this problem using new technology. But is there any guarantee that this feeling won't come up again after some time? It does not matter if it is a micro, nano, or even atomic service; no new buzzword or trend can help us with this problem. So here's the answer you've been looking for: you must explore multiple tactics and strategies in software engineering practices, such as documentation, testing, domain-driven design, persistence, cloud adoption, and the different design and architecture styles. This interaction will cover the ultimate guide to making the best use of architecture and design to guarantee a better, maintainable, and evolutionary solution. You'll also learn how to avoid complex systems and fight against legacy to achieve the desired innovation with stability.

Serverless Event-Driven Services for Spring Developers

Spring Boot provides excellent tools and frameworks for building microservice systems. We've been creating microservices systems for years with Spring Boot and other frameworks, but what about event-driven service systems? This talk is about developing event-driven service systems using Java and annotations. See the next level of service development through an event-driven series of live code examples. See how Spring and Spring-like annotations enable you to build event-sourcing services, CQRS views, and serverless functions deployed to the serverless, database-less, Kubernetes-less, and ops-less Kalix.io PaaS.

Welcome to the Jungle - A safari through the JVM landscape

OpenJDK with it’s Java Virtual Machine is great but there is not only one flavour but many. There is Oracle OpenJDK, Eclipse Temurin, IBM Semeru, Amazon Corretto, Azul Zulu, Alibaba Dragonwell, Huawei Bi Sheng, Tencent Kona and many more. Did you ever ask yourself which one is better, faster, free or something similar? Or do you want to know where the differences are in those distributions, well then this session might bring some answers to your questions. It will give you an idea about what the JVM is and will cover all the available distributions not only of OpenJDK but also of GraalVM and will try to explain the differences and features of the available distributions. It will also try to give you an idea what JVM to use for specific use cases.

Lessons learned from working with 2000 event-driven microservices

Wix has a huge scale of event driven traffic. More than 70 billion Kafka business events per day. Over the past few years Wix has made a gradual transition to an event-driven architecture for its 2000 microservices. We have made mistakes along the way but have improved and learned a lot about how to make sure our production is still maintainable, performant and resilient. In this talk you will hear about the lessons we learned including: 1. The importance of atomic operations for databases and events 2. avoiding data consistency issues due to out-of-order and duplicate processing 3. Having essential events debugging and quick-fix tools in production and a few more

Take Agile to the next level using InnerSource

InnerSource adopts OpenSource practices to code and helps reduce dependencies between development teams, break silos, as well as increases knowledge-sharing within the company. This approach can increase agility in your organization and take it to the next level. During this session, Katarzyna Osuch-Bukowska will present a real example of InnerSource implementation among 12 Agile teams in a department of over 100 software engineers at Grand Parade. Based on this experience, she will also highlight pros & cons of this practice - in what context InnerSource works and where it should be avoided. Target audience: Software developers, Scrum Masters, Managers, Product Owners, Leaders

Data-oriented programming in Java

With the changes made to the Java language in recent releases, it has moved into a new realm: Data-oriented programming. In this talk, I will explain what data-oriented programming is and explain the principles it is based upon. When it comes to microservices, object-oriented programming is no longer the only paradigm in Java development. I will also show how recent language additions such as records, sealed classes, pattern matching, and switch functions support the concept of data-oriented programming. This will be done by converting a simple object-oriented application into a data-oriented version. In his June 2022 paper in InfoQ Java language architect Brian Goetz introduced the concept of data-oriented programming in Java (https://www.infoq.com/articles/data-oriented-programming-java/) While this may offer significant advantages, especially in the realm of microservices, much is still unknown. I will explain what the concepts are and how the Java language can be used.

Introduction and pitfalls of Java's new concurrency model

Java 19 will preview one of the most anticipated features, virtual threads, and structured concurrency. It rethinks the way multithreading works in Java. It was born out of the idea that reactive Java is too complicated and blocking threads has to be cheap. Resulting in the new virtual threads that we run thousands of! The aim of virtual threads and structured concurrency is to have high-throughput lightweight threads and new programming models on the Java platform. In this talk, I will demonstrate virtual threads and how to create and manage them using structured concurrency. Furthermore, I'll provide some practical advice to avoid pitfalls when you start using virtual threads in your application.

Linux terminal for java developers — boost your efficiency!

What makes you an expert (Warning! A huge simplification! :)) is a blend of knowledge (which allows you to solve complex problems every day) and skills (that let you perform your tasks efficiently when you already know how to achieve your goal). Basically, knowledge is a key which you operate with your skills. Combined, they make up your expertise in a particular area. This session will be about skills that improve your efficiency in general. I want to show how you can use the Linux terminal for everyday tasks, what tools are at your disposal, and how to start automating 'all the small things' with ease. My main goal is to give you an idea of how these tools can serve you and your needs. Ingredients: 15% thoughts, 85% live session with linux terminal

Unicorn's baby steps: what should you know (& do) as a first-time startup CTO

Startup's early days aren't easy: there are always too many topics on your plate and everything is of the highest priority. As a first-time CTO you have to pick your battles wisely - I'll try to help by sharing my experience as a former startup CTO and a person who cooperates with startups on daily basis. There is no single blueprint to follow, but we'll go through major decision points, key concerns to be addressed, most pressing questions to be answered. To illustrate the challenges covered and make it an interactive experience, we will create an artificial startup and take it for a virtual spin together.

Domain Experiments

Our clients don't know what they need. This happens because no one can foresee the future. Requirements will evolve and change rapidly over the lifecycle of the project. That's why we need to constantly refine systems. We can keep building and discarding prototypes, but it's extremely costly. Often we can't afford to rewrite everything from scratch only because some new domain insights were discovered. This eventually leads to a mismatched model. Is there another way? We can focus on domain only and refine our model through examples, until we find the right conceptual contours (http://ddd.fed.wiki.org/view/welcome-visitors/view/conceptual-contours). Each such iteration of the model is a kind of experiment challenging the upfront decisions. During this presentation I'm going to show how you can use example mapping combined with business-oriented TDD to be able to run rapid experiments directly on the domain model, without a need to rewrite the system again.

Discover BigQuery ML, build your own CREATE MODEL stmt

With BigQuery ML, you can build machine learning models without leaving the database environment and training it on massive datasets. In this demo session we are going to demonstrate common marketing Machine Learning use cases of how to build, train, eval, and predict, your own scalable machine learning models using SQL language in Google BigQuery and to address the following use cases: - Customer Segmentation + Product cross sale recommendation - Conversion/Purchase prediction - Inference with other in-built >20 models The audience will get first-hand experience with how to write CREATE MODEL sql syntax to build machine learning models such as: - Multiclass logistic regression for classification - K-means clustering - Matrix factorization - ARIMA time series predictions ... and more Models are trained and accessed in BigQuery using SQL — a language data analysts know. This enables business decision-making through predictive analytics across the organization without leaving the query editor. In the end, the audience will learn how everyday developers can build/train/run their own machine-learning models straight from the database query editor, by issuing CREATE MODEL statements

Understanding Probabilistic Data Structures with 112,092 UFO Sightings

There are three reactions to the title of this talk:
- What the heck’s a probabilistic data structure?
- UFO Sightings… wha?
- 112,092 is an oddly specific number.
This is a talk about the first bullet point with the second thrown in just for fun. I like weird stuff—UFOs, Bigfoot, peanut butter and bologna on toast—maybe you do too? As far as the third bullet point, well, that’s how many sightings I have. Now, if you’re like most developers, you probably have no idea what probabilistic data structures are. In fact, I did a super-scientific poll on Twitter and found that out of 119 participants, 58% had never heard of them and 22% had heard the term but nothing more. I wonder what percentage of that 22% heard the term for the first time in the poll. We’re a literal-minded lot at times. Anyhow. That’s 4 out of 5 developers or, as I like to call it, the Trident dentist ratio. (It’s actually a manifestation of the Pareto principle but I’m a 70s kid). That’s a lot of folks that need to be educated. So, let’s do that. A probabilistic data structure is, well, they’re sort of like the TARDIS—bigger on the inside—and JPEG compression—a bit lossy. And, like both, they are fast, accurate enough, and can take you to interesting places of adventure. That last one might not be something a JPEG does. More technically speaking, most probabilistic data structures use hashes to give you faster and smaller data structures in exchange for precision. If you’ve got a mountain of data to process, this is super useful. In this talk, we’ll briefly go over some common probabilistic data structures; dive deep into a couple (Bloom Filter, MinHash, and Top-K); and show a running application that makes use of Top-K to analyze the most commonly used words in all 112,092 of my UFO sightings. When we’re done, you’ll be ready to start using some of these structures in your own applications. And, if you use the UFO data, maybe you’ll discover that the truth really is out there.

Tracking Aircraft with Software-Defined Radio

Aircraft are everywhere. Knowing exactly where is paramount as it’s considered bad form for two aircraft to be in the same place at the same time. To avoid this, aircraft worldwide constantly and publicly broadcast their location, heading, and all sorts of other data using a system called ADS-B or Automatic Dependent Surveillance Broadcast. This data is easy to capture using using a combination of a cheap radio dongle and free software—a combination called software-defined radio. Once captured, we can do pretty much anything we want. I've decided to capture it in an event stream, shove it down a websocket, and put it on a map. In this lighting talk, I'll show how software-defined radio works by using it to capture live radio transmissions, from both local radio stations and my handheld amateur radio. And, we'll capture live ADS-B transmissions from aircraft transponders in the area to track nearby aircraft in real time!

Modern Java App Development in the Cloud

So you need to have your Java app deployed and available for your users right away—but you would like to do as little managing, wiring, and infrastructure work as possible. How can you achieve that? Well, you go serverless with your containers, using supersonic Java in the cloud. Join as we explore the bleeding-edge Java possibilities with MicroProfile and Quarkus on Google Cloud Run. With MicroProfile, you can switch to another app server with no changes to your code.

Why You Want to Code With Quarkus in 2023

In this session, we’ll have a look why you want to try out “supersonic, subatomic Java” with Quarkus. If you’re familiar with enterprise development with Spring or Java EE, you’ll be delighted to see the effective way of working that Quarkus allows. We’ll see a few reasons why coding with Quarkus not only makes our work more effective but is also fun. We will have a look at the coding experience, turnaround times, Quarkus' dev mode, container & Kubernetes support, persistence, and templating. Join us for this live-coding-only session!

Demystifying ‘Event’ Related Software Concepts and Methodologies

Unless you've been hiding deep under a rock for the last decade, at least a few terms starting with the word 'event' must have invaded your professional space. 'Event-driven' has already evolved to the level of a magical buzzword in IT marketing and sales activities. But the tech terms list is much longer. It includes 'event streaming', 'event storming', 'event sourcing', 'event store', 'event modeling', 'event notification', 'event-carried state transfer', ... Getting dizzy already? Don't worry. Many developers feel this way. This talk is an “event-dizziness” cure. It'll walk you through the entire 'event land' and explain what is what. It’ll discuss the origins, intention, and applicability of each term. So the next time you face the 'event-driven' label, you can ask the right questions and make educated choices.

Supercharge your Native Image applications

You’ve probably heard of GraalVM Native Image and how great it is for reducing startup time and memory consumption — but do you know how to use it to the fullest in practice? In this hands-on session we’ll look at how to develop and test Native Image applications, optimize their performance, configure using popular libraries, monitor applications, and more!

Machine Intelligence With Humans in Mind

We are in a rapidly changing world of globalization and digitalization, where computer ethics has become significantly important. Machine intelligence is growing in a way that is difficult for humans to comprehend and even more challenging to control. Focus on computer ethics goes beyond protecting personal and commercial information. What are the responsibilities of companies, developers, and users, and how can we overcome the lack of awareness of computer ethics? In this talk, we will look at the importance of computer ethics in our daily life as tech people and as users in the digital world and how we can start taking action.

From a rebellious individualist reinventing the wheel to a knowledge-sharing enthusiast. A look at mentoring in retrospect

When I joined a large corporation while still being a student, I was not enthusiastic about the idea of working with a mentor on a regular basis. I considered it infeasible to put my full trust into a person to whom I was assigned rather randomly. I preferred to search for my own growth direction and plan my career path myself, blindly. Everything changed after a few years, when I myself was to become a mentor for people starting their careers as programmers. Wanting to prepare myself for this role as thoroughly as possible, I realized how important and necessary mentoring actually was. During my talk, I will share my experiences as both a student and a mentor, as well as summarize all the important facts about the art of mentoring that I have learned over the years.

Bare metal Java

Java, in fact JVM, has a well-deserved fame as a hardware-unfriendly platform, and therefore nobody (except Apache Kafka, Elastic, Cassandra and Neo4j) will build databases, queues and other solutions where 'mechanical sympathy' is crucial , in Java. Garbage collector, speculating JIT, lack of control over 'object layout', terrible support (mostly due to lack of abstraction) for modern processors and operating systems. And there is also JNI (who was there, I know what I'm talking about). (I do not mention the implementation of IO) The purpose of this presentation is to disenchant these myths and to show how much effort has recently been going into making JVM more hardware friendly. It will be about APIs which are still in the incubation phase. You may never see these APIs in your life, but they will be a foundation of databases, queue brokers and game engines (I am not joking) in the future. I will focus on a foreign functions & memory JEP. We will learn how to work with native memory (with seatbelts fastened), downcall and upcall C functions from Java (with ease). Everything will be dipped in a sauce of broken examples and distorted micro benchmarks and OpenJDK compiled five minutes before the presentation.

The Hacker’s Guide to Kubernetes

Kubernetes is the most popular container orchestration platform for automated deployment, scaling, and management of containerized applications. With more and more applications running in Kubernetes, it is crucial to understand Kubernetes security risks. This talk guides you through various security risk of Kubernetes, focusing on OWASP Kubernetes Top 10 list. In live demos, you will find out how to exploit a range of vulnerabilities or misconfigurations in your k8s clusters, attacking containers, pods, network, or k8s components, leading to an ultimate compromise of user accounts in an exemplary web application. You will learn about common mistakes and vulnerabilities along with the best practices for hardening of your Kubernetes systems.

The origin of the feature

Programming languages are constantly evolving. Even Java, a very conservative language for much of its history, has been developing rapidly in recent years. As someone in the middle of programming language development, I want to show you where new language features come from and how a decision is made about whether or not an addition fits the language. You'll see what distinguishes excellent language features from bad ones and why some features are valued in one language but are flawed in another. We will also explore two thought-provoking questions: 'Is every new idea in programming just another rehash of what was known before?' and 'Will we ever have one perfect programming language fitting all our needs?'

Frameworks Unplugged: Building Distributed Systems in Pure Java

Building a hello-world REST example in spring-boot does not take more than a couple of minutes. ChatGPT generates it within seconds (including the maven files), and the example will probably let you pass java programming 101. You can ask ChatGPT to add a distributed cache to your application, and it will provide a good recipe for embedding Hazelcast into your java solution. The same goes for database access, choosing a persistence framework, etc. These are becoming everyday, menial tasks a supervised machine can perform independently. Does this mean software engineering is in decline, developers are no longer needed, and we should look for a new job? And this presentation will be about carpentry? Nope. When we ask the computer how do the REST endpoints work? What are the standard HTTP methods such as GET, POST, PUT, DELETE, and how does the computer know which method I'm calling - the responses become vaguer and vaguer. How does a distributed system know its state, and how do clusters discover members? These are trickier questions, and one needs to know what to ask for. So there is a chance for us. We still have a role to play in this engineering wishy-washy. We need to understand the basics which support the frameworks we use daily - and that's what we will focus on during this session. Not just by scratching a surface, not by an academic lecture. We will dive into the code and implement a simple cluster, distributed system replicating data over the network. No frameworks, just Java code and principles, definitions and algorithms underlying our everyday work. What can possibly go wrong?

Respect estimates (Room 1)

„Software is hard” was written by Donald Knuth. We, however make it even harder by focusing our efforts in the wrong directions. Quite often because we think(!) we follow good practices. What really we do is a cult, sometimes even a „cargo cult”. In the talk I will present some examples of wastes and cults that we do in everyday activities. This includes estimates, tests, agile meetings and architecture of our systems. We continue on doing some practices, even though we have completely lost original intention or the world has changed so much that they are not needed any more. I will give some hints how to recognize such „cults” and eliminate them from your projects.

Integration tests are needed and simple

The pyramids in Egypt were built in ancient times. We still admire them today, appreciating the craftsmanship and hard work of their builders. However, do we build houses from giant stone blocks today? Not likely, current times bring other needs and offer other technologies. Pyramids of testing were also built some time ago. We admire legacy projects with a rich set of tests, but do we create projects today the same way we did 10-15-20 years ago? If not, why do we still want to test them the same way? Maybe the shape of today's projects' tests should no longer resemble a pyramid? Our needs are different, and the possibilities, thanks to the Testcontainers family of libraries, have also advanced a lot. If you have a feeling that integration testing can bring a lot to your project, but somehow you haven't had the chance to get acquainted with Testcontainers so far, or you're afraid that it's just 'magic for top developers', this lecture is for you. We will quickly, easily and pleasantly rearrange the pyramids of our times ;-)

What can go wrong with the distributed system - the Hazelcast experience

Hazelcast is an in-memory distributed computation and storage platform. It is implemented in raw Java, with our RPC and concurrency stack, distributed primitives, replication and Raft-based consensus protocol. And, of course, with our set of known and unknown issues. In this talk, on the example of our distributed-related issues, we will discuss what you should care about while building a distributed system.

A pragmatic quick guide to TDD

Testing our code is something we all know we should do. It is on the same level as we know that it is good to floss our teeth. Testing can be done before or after the code is written. Adding tests when the code is written is a chore. It is much more fun, and we get much better results, if we use tests to drive the development. Writing the test first forces you to think of the output, and forces you to take small steps when the solution is not clear from the beginning. Writing the test first also enables you to refactor your code without being worried that you will break something. Let’s explore test first development a bit. We are developers and we are paid to deliver working software. We need a practical point of view. Let’s use tests as drivers to build a small application live. Getting into the habit of flossing teeth is not my area of expertise so I’ll avoid that. Today we are lucky, we only need to build the backend. However, we need to build the backend with proper database support. And it should be thoroughly tested because we don’t want to disappoint our users and get extra work when we thought we were done. The tool chain I will use is very much middle of the road. We’ll use Maven for building, Spring Boot for serving, and PostgreSQL for persisting. Nothing interesting to see there. The interesting part is the usage of the test of tools as drivers and good abstractions for testability. This is a live code session and the result will be shared at GitHub at the end of the session for you to explore, play around with, and use at work tomorrow.

How shit works: Databases

The last decade has seen a proliferation in data storage technologies, from MongoDB to ElasticSearch to Riak to Datomic and so many others: relational databases, document stores, key-value stores… oh my! So many choices, so much confusion. While fundamentally different products, all of these solve the same age-old problem: that of storing and managing data on a persistent medium. Yet despite using them every day, we are often confounded by how they operate, treating them as magical devices that require special care. No more! They say a little knowledge is a dangerous thing… care to find out?

Effects: to be or not to be?

Static typing is hardly controversial, but how far should we push the type system? What information should the types include, and what properties should they prove? That’s where effect systems come in, but unlike the general approach, their answers to the questions above are hot debate topics! Navigating the design space isn’t easy. Before we make up our minds, more questions need answering first: why do we need an effect system at all? How do effect systems differ? What are their tradeoffs? Let’s explore the options in Scala, the JVM, and beyond.

Improve DevX at scale with Serverless

Traditionally, software was developed in closed systems using on-prem hardware. Today we are breaking down the siloed way of working at Philips by moving the code and CI/CD jobs to the cloud. To enable our software community to co-create software based on InnerSource principles, we are onboarding 8000+ developers to GitHub and go beyond code by investing in an open collaboration culture and modern ways of working. One of the key catalysts of this endeavor is having self-hosted action runners available by default to everyone. Teams no longer need to host, maintain, and secure their own build servers. They can simply opt-in to the standard auto-scaling AWS cloud-based fleet of runners. The solution built, and open sourced by Philips, scales runners using a Serverless control plane. Based on load, runners are created (scaled up) or destroyed (scale down). Users of the solution can choose the type of operating system and architecture, utilize AWS Spot Instances, define network layers, and run workloads 100% ephemeral. The solution is advised by GitHub and used by small start-ups and large enterprises. In this talk we’ll discuss our journey to move to the cloud from an on-prem solution, discuss the solution (including demo), tips and advice on overcoming common challenges and how the solution brings the same experience to developers when using the managed solution

Apache Camel 4: what to expect

On January 4th, 2023, our community announced the roadmap for the next major version of Apache Camel 4. I will present the major features and changes introduced in this new version. I will also describe our roadmap, short-term plans, and how it affects Camel 3. At the end of this talk, the audience should have learned about the new features and changes, how they might affect them, and how they can prepare for migrating to this new release.

Developers kryptonite

Clark Kent AKA Superman is one of the biggest superheroes of our times, but even he has something, that makes him vulnerable to damage and less awesome. It is the Kryptonite that weakens him. Developers, just like superheroes, also have their kryptonite. During this talk, I will try to show you what and why makes developers less effective and less satisfied with their projects. I will talk about architecture as well as psychology.

Major migrations made easy

Conferences love to show you the latest and greatest framework versions and language features. But those new technologies can feel a world away back at work. And it can be hard to justify the time spent to upgrade something that’s not broken, such as JUnit 4. What if you could migrate in mere minutes? With OpenRewrite you can! A collection of fine grained recipes combine to achieve large scale migrations of frameworks and tools related to the JVM. And since it uses a lossless semantic tree, refactorings are guaranteed safe. Upgrade Spring, Micronaut and Quarkus. Adopt JUnit 5; switch to AssertJ. Replace Log4j with Logback. Fix Sonar and Checkstyle violations. A world of quick and easy migrations awaits!

Things I wish I knew before I started with event sourcing

So, you've heard about this event sourcing thing and eager to try it? Looks great, gives you events history, auditing, read models you can build for given use case and rebuild at any time and so on. It has it's pros indeed (a lot), it also has some cons (well, there is no silver bullet), but there are things that you can only learn and truly understand when you hit the problem and experience it for real. How it all works and how it fits in the real world systems? There are few gems and tricks in all this event sourcing world that I learned over time that I'd like to show you. What to watch for when choosing that architecture, what to avoid and how to do certain things in an event-sourced way for successful long running project. I hope this talk will either save you from making few of the mistakes I did (or was close to doing so) or at least shed some more light on event sourcing in practical aspect.

Building High Performance Real-time Stream Processing Microservices

Real-time stream processing is growing exponentially in recent years, businesses need to gather insights from real-time data as soon as it’s generated. To do this, developers and software architects use various pipelines and tools to capture and process data in motion. Real-time stream processing has its own challenges such as testing and life-cycle management, scaling and performance, event time and late events, streaming fault tolerance, and processing guarantees. In this talk, I will address those challenges and demonstrate the best practices for real-time stream processing, from data ingestion to data processing with ultra-low latency at scale and at speed, using the Hazelcast platform. I will discuss how you can optimize your real-time streaming projects in the following areas: scalability, performance, failover, reliability, and data recovery.

Fighting the Technical Debt of GlassFish

GlassFish is back, better than it ever was, but there's still a long path to go. Is it worth to fight the technical debt of last 20 years? Isn't it insane? There are many similar projects, both important and obsoleted, too large and complicated to build them again on a green field. Too many companies are afraid of radical changes, while their projects are less and less secure, usable, capable of integration with modern technologies. They are not scalable but often their load increases exponentially. What they can do? How expensive it can be? What is the outcome? Let's take the GlassFish as an example. Where does the GlassFish swim? Do you still remember the word 'agile'?

Chopping the monolith

Microservices are ubiquitous. However, most companies that implement micro services do not reap their full benefits - at best. At worst, it’s an epic failure. There are reasons for micro services: independent deployment of business capabilities. However, the unspoken assumption is that you need to deploy all capabilities all the time. My experience has shown me that it’s plain wrong. Some capabilities need frequent deployment, while some are much more stable. In “the past”, we used Rule Engines to allow updating business rules without deployment. While it solved the problem, this approach had issues. Between introducing a Rule Engine and migrating your complete system to micro services, I believe that there’s a middle path, and that this path is Function-as-a-Service. In this talk, I’ll detail every point I’ve made above, and show how one can use Serverless to pragmatically design a system that allows deploying as often as you need.

The road to world-class observability

In this talk, I want to share the experience I have gained throughout the years on correctly implementing observability for distributed and scalable systems. I will be able to share the following:

Maintain Social Distance this Spring

One would think that building applications just by using a single annotation is the holy grail of software development. Unfortunately, it turns out that dark magic techniques sometimes backfire... During this presentation, we'll discuss the downsides of using invasive frameworks and some techniques that allow us to mitigate the risks of serious injuries. If Hibernate is your first choice and you are not Vlad Mihalcea, this presentation is for you.

Large-Scale Distributed Processing in Google Cloud - 7 lessons learned

Distributed processing of many TBs of data per day with traffic over 10k messages per second may be challenging. To ensure the most efficient and cost-effective design of distributed processing of big data, it is important to understand its main characteristics. This presentation will cover the challenges that may arise, such as processing bottlenecks, inefficient usage of compute resources, and high cost. Additionally, attendees will learn how to monitor, detect, and troubleshoot problems using Google Cloud Console UI. Seven cases will be examined, with code and configuration examples provided, along with a solution or recommendation based on real-world scenarios. The target of this presentation is big data cloud experts, but if the audience is not experienced enough, Bartosz can also give necessary introduction.

Be careful `walking with the skeleton`

The topic I would like to speak about: 'Be careful 'walking with the skeleton'. (Target audience - daily user/expert) (15 minutes) A couple of times I faced a situation when the 'walking skeleton' approach wasn't clearly understood by all process members. At some point application state looks very similar to the Minimum Viable Product or 'Happy path'. From different points of view, the situation may look completely different. It may build misunderstanding, underestimations, and false expectations, but there are some key differences between them. I would like to point out the most dangerous places like - fast results first and a long polishing process later. As 'walking skeleton' covers even fewer cases than Happy path and is not a working version like in MVP. At some point, implemented functionality can be treated as a different project completion state. I would like to show how improved communication and visualization can prevent misunderstandings. For example, detailed schema or mockups for specific functionality together with done/undone/in-progress feature markers can help to bring everyone to the same point and clarify the understanding of the current state.

Helidon Nima - Loom based microservices framework

Do you really like reactive programming? What if I told you that the same performance is achievable with imperative coding style? With virtual threads coming to Java we can once again keep our code base clean and maintainable. Thanks to project Loom in JDK, the paradigm can shift once more even for applications that require high concurrency. I will describe performance problems which most of the modern frameworks solve by forcing developers to enter the dark world of reactive programming. Then I will introduce Helidon Nima - new microservices framework which is built on top of a server designed for Loom with fully synchronous routing that can block as needed, yet still provide high performance under heavy concurrent load. I'll also talk about challenges, benefits and impact on application development in such an environment. - Is it the end of reactive programming?

OpenTelemetry Metrics: observability’s holy grail

OpenTelemetry Metrics is making a revolution both for microservices and libraries. I believe it is the most comprehensive metrics library ever written. This talk will guide us through understanding OTel as a whole, continue with OTel Metrics benefits, concepts, and entities in its API and SDK. Once done, you'll understand why it's so good, how it will benefit you, and why it will be the de facto metrics library. The examples will be in Java, but as you'll see, it's almost the same in any language.

Property-based testing - let your testing library work for you

Don't ask what you can do for your testing library, ask what it can do for you! So what can it do? It turns out that much more than displaying a nice green and red report. What if we make the library generate the test data? And while we're at it, maybe it could also think of the edge cases for which our code is wrong? Oh, and when it finds them, it should simplify them a bit before returning to us, so that we can quickly identify the root cause of the problem. And repeat that a thousand times, just to be sure. Sounds good? That's exactly what property-based testing has to offer. I'll show how to get started with this kind of testing, using jqwik (https://jqwik.net/) as an example. But isn't it all too good to be true, surely there's some fine print? Of course there is. I'll cover that as well.

The art of investigating problems in software

Get ready to sharpen your detective skills and put your problem-solving abilities to the test! In 'The Art of Investigating Problems in Software,' we'll explore the art of debugging and the many techniques used to solve software issues. Based on real-world situations and backed by years of experience, you'll learn how to piece together the clues and tackle the most challenging glitches like a pro. So come join us and discover the many ways to crack the code and get to the bottom of any software problem.

Keep cool and maintain an open source project

When working on an open source project, whether at your job or in your free time, it might often become a burden and become a chore instead of a pleasant experience. You might get swamped with issues, discussions and people always double guessing a lot of your decisions. I believe that it’s possible to fix that and make the project a safe space for you and your contributors to operate and thrive within. I am maintaining a couple of medium sized open source projects and I wanted to give some quick rundown of rules and guidelines that can help you in retaining the joy of working with open source instead of turning it into a slippery slope to burndown.

Determinedly deterministic and how it can help you

We will walk through what determinism means, how you can put in into practice and the substantial benefits this brings you as a developer. LMAX runs a financial exchange where the core of the system is a matching engine - a giant state machine. For a matching engine, or any state machine, ensuring that you can mutate it in a deterministic manner is key. Is reliability, easy system recovery and focus on writing (probably) the fastest Java code in the world on your list of interests? Join us to see how a single decision changed the way reason about code and problems we solve, and made our lives easier!

Cloud Agnostic Data Platform with DBT, Trino, Iceberg and MinIO

In Data Analytics, while the number of open-source solutions is continuously increasing, also cloud-native solutions follow the same patterns. Although the Dockerized and Kubernetes-based solutions are pretty stable in terms of price and keep fitting cloud and on-premise solutions, sometimes the cloud-native might be expensive and overfit the use case. Our goal is to give a hands-on and ready-to-use data pipeline based on TrinoDB, DBT, and MinIO that with the power of Apache Iceberg, will provide a scalable, lightweight, and cloud agnostic for your Data Analytical Platform.

How to make your electrons do more in Java

This is two part talk - in first one I want to tell you a story about one of the most not-spoken-of additions in new Java releases - Vector API - to show how it can be used, what is it good for and what gains are there for you. In second one I want to show you that in your machines there is more processing power that you are harnessing in your day to day development with JVM and show you that there are people trying to bring this power to JVM world. They are authors of TornadoVM - a hybrid solution which Is using GraalVM and other native-code tooling to run your computations on GPUs and FPGAs. Everything served in well known syntax and easy to comprehend constructs known from many languages (not only Java). There will be talking, live coding and benchmarks - so lots of fun and amusement.

Event-driven autoscaling for Serverless Java

Kubernetes makes it possible to autoscale various business use cases from web apps to mobile, IoT edge streaming, and AI/ML in more reliable and stable ways. One caveat of Kubernetes autoscaling is based on hardware resource utilization (CPU, memory) through Horizontal Pod Autoscaling. This causes a new challenge to build an event-driven serverless Java on Kubernetes because the event metrics from multiple event sources (e.g., Apache Kafka, AWS SQS) are more relevant than a pod's CPU usage for deciding when applications need to be scaled out and in. Fortunately, KEDA and Knative on Kubernetes are designed to solve this challenge by autoscaling both standard apps and serverless by event metrics in a separate way. This session will teach you how to redesign your Kubernetes autoscaling architecture by event-driven metrics from Apache Kafka over standard resources (CPU, Memory) with Knative and KEDA integration for serverless Java using Quarkus.

Building Your Own Bot with GPT: Harnessing the Power of AI for Personalized Conversations

OpenAI's GPT-based language models have made it easy to build conversational agents that can respond to a wide range of queries. However, these models are not trained on personal data, which limits their ability to provide tailored responses. This talk will focus on how to leverage OpenAI's APIs to build a personal chatbot that can provide personalized responses based on an individual's data. We will explore the technical aspects of building a custom data set and “training” a GPT-based model using OpenAI's API, and explore various strategies that can be used to improve the performance of the chatbot.

Clean & Hexagonal Architecture - it really works!

In IT industry we have a repeatable problem of code debt, which steals happiness from our work, inducing horrible stress and frustration. On the other hand frameworks, architectural approaches, tests cost us supposedly wasted time and they seem not to deliver their promises. In the presentation I'll show you Clean Architecture and Hexagonal Architecture in practice. You will also experience how those approaches interact with Event Storming, Spring Boot and Kotlin. Using Open Source Labella application I'll show you: - what potential problems I wanted to solve using those techniques - what real problems were solved and what challenges arised from them - and summarise, what in my opinion, these practices are meant for Spoiler Alert: These techniques deliver their promises, just not in the way we expect.

Unlock your autonomy. Improve your software design

We want to be autonomous, to create and own our professional pathway. During my talk, I will show you that companies really need autonomous engineers and teams as autonomy is crucial for effective software design. I will also share with you my tips on how to establish and develop your autonomy based on my experience of working with IT organizations. If you are curious about what the secret sauce of autonomy is, come and join my session.

Performance Testing is not only API

When you think of performance tests, you probably mean tests at the API or GUI level. And you are right! Because they are usually enough. What happens when we need something more? Are you familiar with the Shift-Left approach? What if we applied this concept to performance tests? What if you could use your existing tests (including unit tests!) to do it cheaply? Let's find out! Using tests at the lowest level of the testing pyramid you can choose one of three solutions to achieve the aforementioned concept. Using a well-known library (with license limitations), going with an open-source project (with multiple issues), or coding your own solution. When you make your decision you still have a lot to think about. How to choose the best methods to cover? What to do with the raw results? Should it be used as a prevention or baseline? Within this talk, I would love to share the path I took and the lessons learned. Last but not least. Did we manage to go live or did it end as POC?

High-Performance Java-Cloud-Native Apps

Java has been the leading programming language for more than 20 years. However, many people still believe that Java is too complex, heavyweight and memory-hungry. Today, other languages and especially modern serverless approaches seem to overtake Java more and more. What are the plans for Java, is Java also suited for the cloud, what is coming next and, why should I continue to use Java in the future? Good news: The holy grail is already found! With GraalVM and a new generation of microservices frameworks, a completely new Java technology stack is emerging that will replace Java as we know it so far and bring Java to a completely new level and establish it in the cloud. Developing native applications with Java, app startup-time in milliseconds, minimal memory footprint, and database access up to 1000x faster. This is not a vision - it is already possible today. In this session, you will learn everything about the Java technology stack of the future and how you can use it to develop lightweight and at the same time ultra-fast cloud-native applications and microservices with Java. While watching our incredible performance demo, you better fasten your seatbelt.

A Journey of Auditlogs from Kafka to Elastic Search

Audit logs are essential part of the dataflow when multiple users modifying the business critical data. Who modified the data is not enough sometime but it also important to know when and what has changed to track the trail. In single mono application it was easier since all the data is centralised at one place. But with micro services this is even harder due to different ownership and data models. As these are audit logs so critical so any lost change could be potential loss. This session is focused on how we have built centralised audit logging platform that can handle any kind of changes performed on different data models. This can scale until what level is required by using managed cloud services Kafka (MSK) and Open Search (Elastic Search). With ultra warm storage this can help to search the data even faster. I will show the whole Architecture as well as demo of the audit log service including how to search the data on Open Search (Elastic Search).

What is animation engineering?

At first glance, animation in games may not seem like a technical subject. One might imagine animators tirelessly crafting characters, which are then simply inserted into a game engine, ready for release. However, the reality is that animation features in games have numerous engineering challenges. For example, have you ever considered how the character is moved during complex animations with non-linear paths? Or why motion must be extracted from such animations? How do we optimize animations to meet CPU requirements? How can we ensure that a character's limbs interact realistically with surfaces rather than appearing to float or slide? And how do we account for variable frame rates? In this presentation, I will provide an introduction to the tools and techniques used by animation engineers to solve these problems.

JVM and Kubernetes walk into a bar...

Running the JVM-based applications on the Kubernetes cluster seems a relatively easy task - it's enough to pack the jar into the container and ready. But is it really? How does container awareness in JVM work? How is it related to the pod's configuration? Spoiler: there are some traps set for you. How to bypass them? We'll dive deep into the containers, JVM, Kubernetes resources management and check how everything is connected to each other.

Hypergrowth scaling made simple

Imagine that you are interviewed at the system design stage for a global banking institution. There is a request to design functionality for the worldwide banking system operating between several continents. You will likely solve this problem by using advanced technologies and cloud solutions, sometimes really advanced ones. That can lead to many problems, including dependence on many technology suppliers. We often make complex problems very complicated, making our lives miserable. This presentation will present a counterintuitive, straightforward, and business-friendly approach to creating a scalable banking system using surprisingly simple architecture and patterns. You will never look at systems of this scale the same way again. In the presentation, I will discuss the extraordinary simplicity of Revolut's architecture, its advantages, and potential difficulties in implementation. We will look into what does it mean that a system is complex, and how to make good architectural decisions to enable fast growth at the hypergrowth stage.

Enums on steroids - let's look at sealed classes!

Probably everyone has already become familiar with the mechanism of sealed classes introduced in Java 17. However, in addition to strict control of the class hierarchy, it also allows for the creation of non-obvious (yet facilitating) mechanisms. One of them will be enums on steroids - and that's what I want to talk about. It will definitely be interesting - feel free to join.

Avoiding mistakes with events, one at a time

Some say: Use events, events are great, all will be great and rosy. Then reality bites, and.. let's talk about strangers you'd rather avoid - mistakes to make when building using events. Things change, evolve, are not and overdelivered, old events start taking a lot of space, and someone is already using the name you wanted?! Expect: problems, symptoms, consequences, and some 'get-out-of' cards. Come for the experience others gained first-hand, so you know what to avoid.

A parallel programming language extension for Java

The notion of 'thread' is a hardware-level concept that made its way into high-level languages. This impedance mismatch is one of the reasons why parallel programming is so complex and so painful, but it doesn't need to be that way. I will present a language-integrated parallel programming model based on a few simple additions to the Java language using compositional operators. This model is based on strong theoretical foundations, which makes it amenable to correctness proofs. I will claim, based on a number of examples, that it makes parallel programming simpler, more intuitive, more general and more efficient.

Closing keynote (Room 1)

...

What Scala Taught Me About Software Engineering

It's no secret that I've been an avid Scala fan for many years, going as far as organizing conferences in my home country. Not having the commercial opportunity to use my favorite language, the last few years have provided ample opportunities to reflect on what I had learned during my time with Scala: What made it so successful, initially? What lessons can I carry over to other languages? Join me as we untangle how Scala shaped the way I approach software engineering to this day.

The early days of CQRS/Event Sourcing

...

Free yourself from networking details by using a Service Mesh

Implementing bulletproof networking is demanding, requires attention to details, corner case testing. Using Service Mesh, you can move this repetitive task to the infrastructure level. Thanks to this, you will easily improve your product stability and reclaim the time you can use to deliver value to your customers. In this talk, I will show you how Kuma can help you implement battle-tested common network code.

Don’t be afraid of graphs! Our journey to a graph database

Working as a software engineer, we often face the difficult choice of selecting a database for our newly created service. It happens that the answer to this question is far from optimal; sometimes the decisive factor are skills that the team possesses, other times we rely on the technologies that are used broadly in the company. There are situations, however, that force us to reach beyond and step out of our comfort zone in search of a perfect database, often among types that are not so common. During the lecture you will have the opportunity to learn about the most common graph database - Neo4J and what’s the story behind it at Allegro.

How to Become a Top-Performing Software Engineer through Real-World Open Source Practices

Are you tired of feeling stuck in your software engineering career? Do you want to learn from the best and take your skills to the next level? Look no further! Our talk will delve into the world of open source, a space where some of the most successful software products have been developed by global teams using high-quality design and reusable practices. The Open Source industry brings mature guidelines and methodologies for enhancing practices of documentation, architectural decisions record, code design and style, testing, and much more. These increasing practices' adoption has a name: Inner Source. Learn why and how adopting proven open-source practices within your organization can bring your documentation, decision-making, code design, and testing quality to the next level. Join us on this journey to success as we showcase the most effective practices from top open-source projects. By the end of our talk, you'll be equipped with the knowledge and skills to take your career to new heights and drive reusability and innovation within your team and organization. Don't miss out on this opportunity to level up your software engineering skills!

5 quick tips to make your Java apps more awesome

'But what is awesome? Well, for instance, an awesome app reacts to failure and still remains functional, can provide information about its status, can provide an easy way of enabling easy way of toggling features, is easy to test, and is fast – it is ready to go to prod right away! We talk about these and other features and show you some options while we build an (slightly opinionated?) demo application from scratch. Join us for this fun evolution of a few lines of code into a modern cloud-native application!'

Enterprise Kotlin: Jakarta EE for Kotlin developers

Kotlin is gaining traction and widespread usage, while Jakarta EE is developing faster than ever. What happens if we mix them together? In this talk, we’ll create a simple application, utilizing many of the Jakarta specifications, including Restful web services, JSON Binding, persistence, Bean Validation and more. We’ll do it in Kotlin, and show you the pitfalls you might run into as well as how to get around them. By the end of the talk, we’ll have a running application, with Kotlin powered by Jakarta EE.

Event-Driven Micro-Minds: Emulating Neural Networks with Microservices for Enhanced Adaptability and Robustness

In this presentation, we introduce an innovative software architecture called event-driven micro-minds, which emulates neural networks by utilizing small, focused microservices. Developers can create systems programmed with instinctive innate behavior by representing neurons as microservices and synapses as event-driven functions. Micro-minds enable hardwired processing flows that pave the way for increased adaptability compared to traditional AI and ML systems. Attendees of this talk will gain insights into the benefits of employing micro-minds for application development, including enhanced adaptability, scalability, and ease of maintenance. We will also delve into practical examples demonstrating how to build robust and adaptable applications using the micro-minds approach. Join me as we explore the potential of event-driven micro-minds and how they can revolutionize how we develop and implement robust, adaptive software systems.

EclipseStore – The new, ultra-fast Java persistence for the cloud

Database development in Java is known as complex, effortful, time-consuming and expensive. Applications are mostly too slow and we spend a lot of time with trying to handle performance issues. Using caches is fine, but this leads to even higher complexity and to a further potential source of errors. Furthermore, traditional monolithic Java applications, Hibernate as a persistence framework and traditional database servers was great combination. However, the cloud, microservices and serverless computing has changed everything. Now, it’s time to rethink persistence. Imagine a new Java persistence that is tiny, leight-weight, pure Java, super simple to use, that enables you to build your data object model fully freely without any design requirements, allows you searching and filtering data in-memory in microseconds – which means up to 1000x faster than traditional Hibernate queries, without the need of any annoying mappings or data conversion, without effortful cache configurations, that works great with microservices and serverless functions, and even saves you 99% database costs in the cloud – that’s what EclipseStore is. But there is only one problem: this rocket is built for Java developers only!

DevOps Transformation from the C-Level point of view (Room 1)

Would you like to see more DevOps practices in your company? Do you know how to convince your top management to invest in tech debt removal? Would you like to become the CTO in future? If so, I invite you to my talk, in which I will tell you about my experience of working with C-Level executives on DevOps Transformations, in particular: • What are their needs. • What they are looking for. • Why are the proper measurements so crucial. • How to get the 'green light' for the true continuous delivery process. And most importantly - how to get funding for your DevOps Transformation. As a takeaway, you will get to know how to fuel DevOps Transformation fire to make it successful in your organization.

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 (Room 1)

Closing ceremony (Room 1)

TBA

To Be Announced

Lightning talk

Talk cancelled

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.

Open Spaces + Part @HEVRE, Beera Meiselsa 18 Street

Party sponsored by N-iX

HEVRE, Meiselsa 18 Street, 1st floor

Lunch - room 5

Grilled chicken in parsley sauce + rice + salad (gluten free)

Lunch - room 3

Beef rolls in tomato and vegies sauce+ roasted potatoes + salad

Lunch - room 2

Delicate vegetable curry with tofu on jasmine rice (vegan)

Lunch - room 5

Chicken rolls stuffed with mushroom&cheese in thyme sauce with boiled potatoes and salad

Lunch - room 3

Penne Bolognese + cheese + salad

Lunch - room 2

Falafel balls with tzatziki sauce + boiled potatoes + salad (vegan, gluten free)

Lunch - room 5

Tender pork loin in forest mushroom + rosemary potatoes + salad (gluten free)

Lunch - room 3

Cod fillet in butter-lemon sauce + wild rice + salad

Lunch - room 2

Galician dumplings and spinach&cheese + salad