Friday, June 25, 2021
Let me tell you why you are here, reading this abstract, attending this conference. No, not because you get a day off if you attend a conference. Not for swag. You’re here to learn.
We learn to become better, but there will always be someone even better at something. What should we do? Quit our profession? Start breeding cats and hamsters to repeat platypus’ success? Or continue doing what we’re doing, but… differently?
What if I told you that the only path for a successful developer is to start making Badass Software? Don’t know what is it? Don’t worry, you may have been creating it already! Or that idea that you had a couple of years ago - may have turned into something Badass! Not “popular”. Not “cool”. Not “in Scala”. Badass. And I will explain to you what it means and how to create it.
Instead of spending too much time on infrastructure, take advantage of readily available serverless solutions. Focus on your Micronaut code, and deploy it rapidly as a function, an application, or within a container, on Google Cloud Platform, with Cloud Functions, App Engine, or Cloud Run.
In this presentation, you’ll discover the options you have to deploy your Micronaut applications and services on Google Cloud. With Micronaut Launch, it’s easy to get started with a template project, and with a few tweaks, you can then push your code to production.
Thanks to its performance, its low memory consumption, and its lightning-fast startup time, Micronaut is particularly well-suited for services that run on serverless solutions.
The idea of limited work-in-progress (WIP) is coming from Lean methodologies. At its core, it means that new tasks should only be started when the current piece of work is done and delivered. Finding the right work-in-progress limit can increase overall system (organization) throughput. This idea can be applied on many levels including writing code. In this live coding session, I will write FizzBuzzWoof code kata in Kotlin showcasing software development workflows that can be used for limiting work-in-progress. In particular: change size notifications, auto-revert, TDD, TCR (test && commit || revert).
Microservices have become a prevalent architectural approach to developing applications. Moving from a monolithic application to multiple container-based services has many advantages. One of the largest is dynamic scalability; spinning up and shutting down instances of services to adapt to dynamic loads is very cost-effective in a public cloud environment.
For JVM-based applications, running in a managed environment using JIT compilation, this provides additional challenges. Primarily, this is around the time required for a service to warm up and reach the optimum level of performance. To address this, we have seen various approaches such as the Graal VM and Quarkus that use an AOT approach rather than JIT compilation.
In this session, we will explore the pros and cons of both approaches to help in understanding the tradeoff between initial performance and overall
performance. At the end of the session, you will have a clear idea of how to approach your Java microservice design from the AOT and JIT perspective.
The architecture of your application should support you in solving the most complex part of your logic in the most simple possible way. Any other goal of your architecture should be secondary to this. Very often however you don't know where the complexity of your application will pile up, especially in an agile environment where requirements cannot be anticipated. Even in slower-moving environments, time eventually destroys any structure you might plan ahead. What should you do?
This presentation approaches architecture with an evolutionary mindset aimed to Keep your code Short and Simple (KISS) for as long as possible, without adding extra complexity upfront, but always watching out for break-down opportunities and continuously refactoring towards the most simple design that will suit your present needs. Drawing many concepts from the Domain-Driven Development mindset, this talk summarizes the most important lessons learned by designing and implementing 7 real-world projects that Victor lead.
Along the way, we'll cover the essence of: - Value Objects - Entities - Dependency Inversion Principle - Facade aka Application Service - The Onion Architecture (aka Hexagonal, Ports-and-adapters...) - Pure Functions/Imperative Shell ideology - Many real-life pragmatic tips and tricks
Microservices are one of the big trends in software engineering of the last few years; organizing business functionality in several self-contained, loosely coupled services helps teams to work efficiently, make the most suitable technical decisions, and react quickly to new business requirements.
In this session, we'll discuss and showcase how open-source change data capture (CDC) with Debezium can help developers with typical challenges they often face when working on microservices. Come and join us to learn how to:
* Employ the outbox pattern for reliable, eventually consistent data exchange between microservices, without incurring unsafe dual writes or tight coupling
* Gradually extract microservices from existing monolithic applications, using CDC and the strangler fig pattern
* Coordinate long-running business transactions across multiple services using CDC-based saga orchestration, ensuring such activity gets consistently applied or aborted by all participating services
Applications in a microservices architecture can communicate with each other in different ways. Adopting an event-driven paradigm based on asynchronous messaging provides services a way of communicating while reducing runtime coupling. Functions are a natural way of implementing event-driven business logic in terms of suppliers, processors, and consumers. Furthermore, when going serverless, we aim at executables with instant startup and efficiency. Enter Spring.
Spring Cloud Function favors using the functional programming paradigm to implement your business logic and provides useful features to build data pipelines, including type conversion and function composition. Functions can be exposed through different options (like web endpoints or message channels), and adapters are available to run them on platforms like Knative, AWS Lambda, Azure Functions, and GCP Functions. Spring Cloud Stream integrates your functions with messaging systems like RabbitMQ and Kafka without requiring any change to your code. Finally, Spring Native lets you compile your applications as native executable using GraalVM and providing instant startup, instant peak performance, and reduced memory consumption.
Java 16 is really awesome when it comes to "Hello, World!" programs.
It's also cool for sophisticated systems and algorithms, provided their authors write code that obeys a few fairly simple contracts and avoids obvious traps.
There are a few mantras regarding recent features of modern Java, such as:
* records can replace JavaBeans everywhere
* you never need to write `hashCode()` for records
* pattern matching with `instanceof` is the best tool for `equals()`
* just ignore`--illegal-access` and set it to `permit`
* `synchronize (new Long(42))` is the best for monitoring
and so on.
Please join this session to learn how harmful following such mantras can be and how to avoid some obvious misunderstandings about modern Java.
It all started with a small project to pass the time during The Great Quarantine of 2020. I bought some chiles from the local farmer’s market (with proper face coverings and social distancing, of course), fermented my first batch of hot sauce, and shared it with a few friends around the globe. I had no idea the sauce would be such a massive success, so I resolved to build on that triumph in 2021. But this time, I knew that I would have to start from the very beginning and grow the chiles myself. Of course, this presented the wonderful opportunity to combine two of my life’s greatest passions - the culinary arts and technology - to ensure that my growth operation was the ultimate success. Join me in this session where I show you how I used a microcontroller, some sensors, and the cloud to monitor and automate the germination and maturation of this year’s crop.
Your project has reached that stage when it's a good idea to post binaries, but new questions appear such as where should they be posted? How do make it easier for users to install and discover your binaries? Where should releases be announced? Most importantly, can answers to these questions be automated? Enter JReleaser, a tool that provides answers to these questions and more. Come to this session to learn how JReleaser can help you release, publish, and announce binaries with ease, and fast!
Various organizations started to look into serverless as a way of building business logic that can take advantage of the cloud. As it might look at first, it‚Äôs not an easy task to rely strictly on functions that represent independent logic pieces. There is a risk of losing the big picture and by that not having full control over day-to-day operations.
In this session, Maciej will walk you through an approach that allows you to rely on serverless techniques such as functions and cloud events yet still working on the higher-level representation. He will introduce you to Workflow as a Function Flow concept that builds up on top of state of the art technologies such as Microprofile, CloudEvents, and KNative Eventing to deliver a highly scalable business-oriented solution that looks like a single service but runs as a set of functions.
The audience will get an introduction equipped with a set of demonstrations of function flows to prove the ease of use and visibility of the running solution.
University or college does an excellent job of teaching you how to write code. What it doesn’t do is teach you all the other skills you need to be a great developer.
First, I’ll discuss my university and graduate job experience, and its subsequent failure. I’ll then move on to some of the observations I’ve made in the last 20 years while working with numerous development teams. These are observations of skills that great developers have.
I’ll talk about my experience of learning some of those skills, usually the hard way, as part of my recent journey back to development and why having those skills helps to make you a great developer. They include pair programming, estimating, debugging, keeping up with technology, and many more.
Despite the "micro" in the name, real world microservices tend to use a lot of technologies like data persistence, log facades, IoC which aren't always included in the chassis. Hence, Java architects tend to repeat themselves assembling projects with microservices chassis+libraries trying struggling to find the balance between "usefully bloated" and "heavily bloated".
In this presentation I present our(my company's) experience while curating a set of libraries that complement MicroProfile chassis to manage microservices, data migrations and data persistence like:
* Eclipse JKube
Explaining why these libraries are useful and play well in the context of MicroProfile/Jakarta EE and Microservices patterns like those in microservices.io
Later I describe how everyone could curate their libraries and create their archetypes, and how we did it obtaining as product Kukulkan EE:
Spring is all about helping developers get to production quickly and safely. These days, "production" is all but guaranteed to mean Kubernetes, and Spring has you covered. Join me, Spring Developer Advocate Josh Long, and we'll look at how Spring Boot makes writing blisteringly fast, cloud-native, and scalable services more effortless than ever.
Saturday, June 26, 2021
Helidon is a great choice for building microservices. It is a collection of libraries that run on a fast web core powered by Netty. There is full support for CDI, a reactive DB client, and full GraalVM native image support. In addition, Helidon provides an implementation of MicroProfile specification that makes it a good choice for enterprise developers.
In this talk, I will tell you a story, how we found out that Helidon and Kotlin are actually a very nice couple, and how actually we “Kotlinized” Helidon! We will use a huge repository of Helidon in Kotlin examples. You will learn about the language features that make developing Helidon applications a breeze. Along the way, we will take a closer look at the Reactive API to boost the performance of your apps.
Types are a programmer's best friend. In the pursuit of a perfect world, we try to model our domains in such a way that the type system makes incorrect data impossible. In Scala 2, we have tools like type aliases, value classes, or Refined Types. In Scala 3, there's something new for this purpose - opaque type aliases. What do they bring to the table? Will they make our life easier? Do they have any drawbacks? Join this live demo to learn all that and add this new tool to your modeling toolbox!
Runtime code generation is widely used by many state-of-the-art Java frameworks for implementing POJO-centric APIs, but it also opens the door to assembling more modular applications. This presentation offers an introduction to runtime code generation and its use on the Java platform. Furthermore, it discusses the upsides and downsides of several code generation libraries such as ASM, Javassist, cglib, and Byte Buddy.
In this talk, I talk about Java instrumentations and my recent work with Byte Buddy and how to apply code instrumentation. An older version of the talk can be found here: https://www.youtube.com/watch?v=80wCytGEY1g&t=2639s
Java, or JVM, has well-deserved fame as a hardware-unfriendly platform, and thus nobody sane will build database system or solutions where "mechanical sympathy" is crucial. using Java, except Apache Kafka, Elastic, Cassandra and Neo4j ;) ).
Garbage collector, speculating JIT, lack of control over "object layout", terrible support (mainly due to lack of abstraction) for functions of modern processors and operating systems.
And also JNI (who was there, I know what I'm talking about). Complex, slow, no major update since the day of release. Project Panama promises to change it. Simple, fast, safe. This talk will take a look at the state of Project Panama, focusing mainly on the foreign linker, our new interface to C world. Of course, you can expect running examples, core dumps, segfaults and other fancy things.
I will focus on two examples calling C code (from POSIX spec) from Java, and calling Java code from C. We will also touch on the topic of foreign memory as these to specs are tightly coupled together.
Unit Tests by themselves give no guarantee that your system will work in a production environment. That’s where your code will have to work together with other resources like databases and APIs. Unfortunately, those are the kind of dependencies we try to avoid in tests by using mocking-frameworks. Risky business, because this means we’ll only know if the application really works when you push it to production.
In this session, we’ll look at some strategies you can use to test your application without mocking your dependencies away. You’ll discover how tools like Liquibase, TestContainers, WireMock and Pact can immensely improve your tests so you can deploy your application to production AND sleep at night.
Let's be very honest, cloud computing cannot be learned in one day. There are several architectural challenges to deploying your application, such as which framework to choose, reflection or reflectionless, native or non-naive. We also have the operational challenges such as backups, CI/CD, and much more.
This presentation explains how to make some of these design choices and the tradeoffs to consider when building applications to run in a virtual cloud environment.
At first, it seemed to be just a small enhancement: the addition of “Pattern Matching for instanceof” (JEP 305) in Java 14. No more unnecessary casting after an instanceof, that ought to save us a few seconds a day! However, upon further investigation, you’ll quickly discover that pattern matching is not just an enhancement, but rather a vital puzzle piece in the grander scheme of things.
Why were switch expressions added to Java, for example? To make them support pattern matching in a later release! And why did Java 14 bring us records and will Java 15 contain sealed types? Because they could work really well with pattern matching in a later release! These new concepts are the foundation upon which advanced pattern matching features will be built.
Attend this session to get all caught up! You’ll hear about type patterns, deconstruction patterns, nested patterns, and even how pattern matching could improve serialization in the future. Live coding included, of course!
The talk will include an explanation of asynchronous non-blocking programming with code snippets. It will demonstrate how asynchronous non-blocking code helps with resource utilization, isolation beyond just performing I/O in parallel and show how it can be measured/benchmarked. I will present a quick primer on reactive programming. Using a scenario where we need to fetch data from different microservices, we will solve it by leveraging reactive operators to combine different sources of data, perform non-blocking I/O, exception handling, retries, fallbacks and explain how work is scheduled on different threads. Finally, we will go over common mistakes and gotchas with project reactor.
Pattern Matching - the ability to detect a pattern and use it to compute, calculate or extract other values.
Previous versions of Java included a basic set of pattern matches, mostly relying on the developer to code the matches, the extraction or any other usage. Newer and upcoming versions of Java seem to bring in a lot more enhancements in this area and focus heavily on making Java more of a Functional-style language.
This talk is on Pattern Matching present and future, and may include speculative changes which may not compile yet (or ever). The intent is to share some ideas on Pattern Matching, some code samples and discuss the benefits and importance of these new language additions to the language.