J-Santa

We are going to show you what happens when the management lets enterprise Java developers and architects decide how we can control the IoT devices in our new office. While it’s easy to figure out why Microprofile is cool, it’s harder to see how to get in into your project.

By the end of this talk, you will be introduced into the patterns and software in the enterprise world of Java explaining how to build a build a secure, stable, modular, and integrated system on an example of a completely over-engineered IoT solution to control the lights and plant’s well-being in the new office.

Fear not if your system is more complex than controlling light bulbs and plants! This talk will show you how easily you can design a good production-ready Java full-stack system based on the Enterprise stack with Microprofile combined with good continuous deployment infrastructure patterns.

There be code, demos, and (buzzword) dragons.

Microservices, microservices, microservices everywhere! Companies compete with each other, praising the quantity of the microservices they use. Are they obsessed with this? After all, all the distributed systems conceptually resembles a monolith. Services are usually created thoughtlessly, by “brute force”. They don’t even have a support for the unavailability of collaborators… So let’s ask some questions! What benefits do we get by using microservices? In pursuit of competition, we are starting to move towards a dispersed monolith, aren’t we? If you think that the panacea for all evil is the breakdown of monoliths into microservices, then this lecture is not for you.

Code review for many of us has become part and parcel of software development. It is great as it brings tremendous value to our projects. Still, have you ever taken a moment to think about it? Have you ever wondered what value code review brings and why we need it? Have you wondered if our code reviews are good and why some people feel offended by a good review? It is worth asking yourself, what does a good code review mean? If you want to know the answer to these and other questions, and discuss them, I invite you to my lecture.

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 challenge the omni-applicability of immutability, explore what the concept of Persistent Data Structures is, how most common implementations look like, and why it makes things way more complicated that one might think.
We’ll see how much blood, sweat, and tears are required to make the experience of working with immutable data structures at least remotely efficient.

As developers we want to iterate quickly and change our software. On the other hand, we want it to be reliable. And when we change things, they often break. When that happens – and we can’t really avoid that – Operations teams are not happy. They are focused on reliability and change is the enemy.
There’s a gap there, there’s friction between change and stability. And we need to put a bridge over that chasm to cross it. It’s time to break the silos, to own & run what we’ve built. Let’s put software engineering into operations. What could possibly go wrong with that?
During my presentation I’ll share some things I’ve learned during my first year of work as Site Reliability Engineer, including topics such as:
• defining what software reliability means – and why it’s not that simple as it may seem
• measuring reliability, setting goals regarding reliability, working with SLIs, SLOs, and error budget
• how putting operations into the hand of software developers can make software better
• things that Site Reliability Engineers do in their daily jobs
• some tricks or patterns that can increase reliability of our services
• skills that in come handy in SRE work

Have you ever rebuilt an entire application, because you needed to add a new field on the frontend? Or maybe some changes in the database tables have changed all your domain? How to deal with the changing world and requirements? How to maintain order within the application and focus on the domain? How to convert the external world into an implementation detail? The architecture of ports and adapters is the answer.
During the presentation, I will talk about experiences with the applications, where the domain is the most important thing and I will answer four questions:
– What is in it for you?
– How to do it?
– What to keep in mind during implementation?
– Why is it difficult?

Spring is the premier cloud native microservice framework for Java. See how the automatic integrations with Kubernetes strips away all of the operations toil of deploying and maintaining production applications.

Paul will introduce the audience to Kubernetes, and Spring Cloud Kubernetes, He will talk through the various automated integrations for service discovery, configuration, etc. He will demonstrate building a CI/CD pipeline for deploying a spring app and show how Spring integrates seamlessly with Kubernetes as well as CNCF ecosystem projects such as Prometheus and Zipkin for observability.

We all know pain of having big pull requests. It takes time to make code review, fix remarks and bugs and merge to master branch. It requires to have a personal regime to make and push small changes.

test && commit || revert (TCR) is an alternative programming workflow to Test-Driven Development. If the tests pass changes are committed, otherwise all changes since the last successful test run are discarded.
TCR is a workflow which encourages you to make changes in tiny steps (smaller commits). As a result, changes will get out into production faster. TCR “enforce” doing one change at a time. This leads to learn and create good refactoring approaches during a development.

Workflow was created by Oddmund Strømme, Ole Tjensvoll Johannessen and Lars Barlindhaug during code camp with Kent Beck.

At this session we will learn about TCR and compare it to TDD. We will talk about pros, cons and possible ways to include this workflow in commercial environment.
We will start forging an answer to question: Is this a real alternative in the way we create software or is this just a TDD variation which will not hold its ground?

Depending on the size of the application it can happen from a few times a minute to a thousand times a second. New HTTP request comes to Java app. Handling of a request can be divided into few phases: magic, controller, service, repository, even more magic.. to make the matters worse a lot of magic happens between the controller, service and repository!

During this talk I would like to show what happens in those “magical” places also known as abstractions. Understanding them will help you reason about the behaviour of your app and prepare for situations that occur only during peaks of traffic.

If everything seems under control, you’re just not going fast enough.

Have you ever wondered what it takes to make your software run faster?
Have you ever wondered what it takes to become a “performance engineer”?
Or you are doing so-called “adhoc” performance tuning, living your life from
one outage to another severity 1 incident? And you have this strange feeling, that this is
not like things should be?

You have never cared about how your code performances. You knew it was always
problem with database (or somebody else’s problem, blaming others is easy).
It is just hard to admit that you don’t know how to make your code run faster.

Let me be your guide on this trip. I will show you how to, accompanied by tools
like JMH, JFR and flamegraphs, make your code run faster. We will not only focus on tooling but also on the performance tuning process. We are going to talk about times when benchmarks lie,
why data sets are crucial and when more doesn’t mean faster.

During the whole presentation, we will be refactoring and improving the
performance of one, not so trivial code example. Something that everybody knows and something that is fun to implement on your own.

Benchmark, profile, refactor, repeat.

Are you struggling with concurrency? Do you happen to hit strange bugs when executing asynchronously? Are your async functions unreadable even to you? Come and see Kotlin’s concurrency model which addresses all these issues! Start using Kotlin’s coroutines and forget about struggling with Java’s threads or futures. We will go from the basic explanation of what coroutines are, how they help you out in your concurrent programming, how they work under the hood and finishing with the latest additions: Flows, which are Kotlin’s reactive streams built on top of coroutines. Treat yourself to a little comfort this Christmas and start using coroutines!

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.

Java 8 core features: Lambda expressions and Streams API have been widely adopted and popular since their launch. They promote benefits like: conciseness, readability, code reuse and less error prone. Even though they are embraced by the community, many developers are not familiar with under the hood aspects of these syntactic sugar, neither performance considerations involved.

How to deploy my Java application in the cloud?
Can I push my docker containers into the cloud?
Does AWS support microservices somehow?
How many problems I can solve with cloud?
During my presentation, I’ll answer these questions and tell you lot more about running you apps @AWS.

In this live coding session we will refactor a part of some legacy system. We will approach the problem pragmatically, identifying issues and fixing them by applying rules and patterns related to modularity, cohesion, testability, and more. We will also see how Domain Driven Design can help us achieving the goal of a clean and solid code. Code examples will be written in Java.

Unit tests are cheap and we usually have many of them. Many people find unit testing unnecessary because they have seen bad tests that introduce maintenance costs instead of building confidence. However, well-written unit tests help check all paths and avoid regression in business code. I will show some tips and tricks and discuss some controversial topics on which every junior and mid should think about.

Object-relational mapping is very popular programming technique in JVM-based applications. It has its pros and cons. It has both supporters and critics. We can’t, however, say that it’s the only proper way of exchanging data between an application and a database.

I would like to show you an alternative to ORM – jOOQ. I’ll present many use cases. I’ll show you the advantages and disadvantages of jOOQ. We will also take a look at the documentation and licensing policy.

If you don’t want to use ORM (or you cannot) this talk is dedicated to you.

“Just because you’re using Hibernate, doesn’t mean you have to use it for everything.” – Gavin King, author of Hibernate.