Friday, December 4, 2020
Wasn't Java 8 a fantastic update to the language? Lambdas and streams were a huge change and have helped to improve Java developers' productivity and introduce some functional ideas to the language. Then came Java 9... and although the module system is really interesting for certain types of applications, the lack of exciting language features and uncertainty around how painful it might be to migrate to Java 9 left many applications taking a wait-and-see approach, happy with Java 8.
But now Java has a new version every six months, and suddenly Java 15 is here. We're all still on Java 8, wondering
whether we should move to a later version, which one to choose, and how painful it might be to upgrade.
In this session we'll look at:
- Language features from Java 9-15
- Why upgrade from Java 8
- How the support and license changes that came in with Java 11 might impact us.
First, what are they? And why they are important? What do they allow us to do, and what problems do they shield us from? After this talk, you'll inevitably fall in love with pure functions and immutable objects. We'll see how to implement them in Java, in the most geek ways possible. Then, we'll write some code to see their value in terms of refactoring and debugging. Oh, and we'll also have Lombok and records along the way, plus lots of fun while tasting a bit of "a senior developer's night-life".
We're used to defining HTTP API endpoints using annotations (`@GET`, `@Param`, ...), that is, using metadata. Why not take it one step further, and use a "normal" data structure to describe the endpoints? A data structure which we could manipulate and abstract over as any other value in our system.
How would the code look like? What kind of operations can we perform, once our endpoints are represented as data? What do we gain? And do we loose anything? Is the resulting code readable?
In this live-coding talk we'll implement a simple HTTP API from scratch, using Scala and the tapir library, which takes the approach described above. Basic Scala knowledge (or even no Scala knowledge at all) will be sufficient to follow.
Come and see how functional programming improves on the status quo and provides an elegant and flexible solution to an everyday problem!
It is always a challenge when we begin APIs or methods design what to return and how to handle null pointer exception, from that my experience of coaching teams, reviewing developers code, I foud developers obsessed by using Optional but 65% in a wrong way, and introducing new anti-patterns. In this session, I will show attendees with coding the best practice to use Optional class effectively.
Apache Groovy provides several ways to modify and update programs and classes by means of metaprogramming. Some of this options are available at runtime, some others at compile time, and some are even reachable to other JVM languages. These options allow library and framework authors to design better integrations, prototype new language constructs without grammar changes, deliver powerful and and gratifying DSLs, and more. Come to this talk to discover these options and learn how you can put them to work on your projects.
"Can you perform under pressure?" the interviewer asked. I had to resist the urge to sing "PRESSURE! PUSHING DOWN ON ME!" at the top of my lungs. Instead I absent-mindedly said "Sure" and provided a few dull examples to back the claim up.
Still, when you love doing what you do, you'll be happier and your performance will benefit. Being both a developer and a musician, I am happiest when I see music and software come together. When I do a 'git push', I hum "push it to the limit". And when I hear a pop song, I believe the lyrics are actually about software development.
This talk takes you on a journey throughout a typical software development process, showing you where music and software cross paths. And because I'll perform the songs myself, the talk doubles as a mini-concert - featuring songs by Coldplay, Oasis, Imagine Dragons and many more.
BackgroundJob.enqueue(() -> System.out.println("Distributed processing should not be harder than this!"));
Do you have a lot of jobs to process? Are you doing to much in your web-requests, stalling your end-users? Do your jobs take long to complete?
Presenting [JobRunr](https://www.jobrunr.io) - easy to set up, easy to use: add the jar from Maven Central and create jobs using only Java 8 lambda's. If you need to process more jobs than your current server can handle, just add extra nodes - no extra configuration is necessary - JobRunr will automatically share the load over the different nodes.
Are you talking to external webservices that sometimes fail? No worries, JobRunr is fault-tolerant and will automatically retry your jobs with a smart back-off policy.
Oh yeah, one more thing: it comes with a built-in dashboard that allows you to follow up on all your jobs.
In this session explore how Kafka and Reactive application architecture can be combined in applications to better handle our modern data needs.
The need for event-driven architecture with example
Correcting the incorrect assumption that using Kafka give you complete Reactivity and what this really means (i.e. reactive programming, reactive architecture, reactive manifesto)
How to configure Kafka to best enable the cornerstones of the reactive manifesto (with analogies to original example)
How to get started with Kafka
Reactive Kafka frameworks available
Demo application built using Kafka and Vert.x Kafka client and significant changes made when re-architecting this application
Useful resources and helpful links
Good news, everyone! Helidon got a jet engine! Now Helidon is packed with modern, high-tech, James Bond-level features and it flies like a rocket! Also, thanks to a nicely crafted fitness plan, the weight has been reduced and concentration increased - resulting in less RAM consumption and faster waking. Come to my live coding session to learn about all of the new features added in Helidon 2.1; such as GraalVM native image support in Helidon MP, MicroProfile Reactive Streams and Reactive Stream Operators, Helidon DB Client and HTTP Client in Helidon SE. I will also be demonstrating the new command line tool and live-reloading feature which will nitro-boost your development process.
Kotlin has been the new superhero on the JVM team for the last couple of years now.
With significant support from both JetBrains and the community Kotlin has managed to find a good balance between new features and understandability.
However, with great power comes great responsibility.
Every new feature holds new ways to shoot yourself in the foot.
Every bit of syntactic sugar has the potential to introduce an incomprehensible layer of abstraction.
Amongst all the awesome features of Kotlin, which ones have the potential to harm more than they help? Which ones should you handle with care? How do you make sure that your Kotlin code is not only shiny and new, but also genuinely better?
Get ready for the superhero (code)blockbuster of 2021, ‚ÄúThe dangerous side of Kotlin‚Äù!
GraalVM is a high-performance polyglot runtime for dynamic, static, and native languages. Among other things it can compile Java applications ahead-of-time to native binaries which start up really fast, are immediately ready to do useful work, and have much lower memory usage than a typical Java apps. As in milliseconds to start and run well with just a few MB of memory. This ability makes GraalVM ideal runtime for deploying Java applications to the cloud, autoscale to 0, or Function as a Service environments where otherwise you'd think it's a bit awkward to use Java.
You will learn how to use GraalVM as a platform for your cloud Java deployments: building native binaries, profiling your code for the best AOT compilation results, configuring resource consumption based on the best practices and historic data, and reducing the container startup overhead for ultimately fast startup.
Saturday, December 5, 2020
Your ultimate guide to modern applications. What happened to our lovely three-tier systems and why is enterprise software development becoming increasingly complicated? Walk away with new inspirations on what to focus on in the next months and how to stay happy in all this madness.
Many projects are still on Java 8, some already on 11 and yet, these days Java 16 gets released! Java's releases between 9 and 16 have a lot in stock - in this talk you'll learn about...
new language features like sealed types, records, switch expressions, var, and more new APIs like stack walking and the reactive HTTP/2 client the additions to existing APIs, like Stream and Optional other niceties like multi-release JARs and performance improvements After this talk you will be prepared to get started with Java 16.
Java, JavaFX, and a Raspberry Pi are an ideal combination for any project where you want to connect software and hardware (LEDs, buttons, sensors...) with a beautiful, easy-to-use user interface. In this talk, we will go through the process of building a JavaFX touchscreen user interface to control a relay board and an Arduino with LED strips that were needed to solve the problem of getting my son to the dinner table while he is playing the drums...
This includes selecting a Java JDK for Raspberry Pi, setting up a Mosquitto queue, programming the Arduino, understanding the GPIO's on the Raspberry Pi, including a web server, and a lot more...
Hardware experiments may seem challenging but with some basic knowledge and cheap components, you'll discover it's a great way to learn a lot of new stuff!
So you've built / found the perfect Deep Learning model, now how do you put that into production and maintain it? This talk is all about Machine Learning Software Engineering (MLEng) on the Cloud using Java technologies. In particular we will cover :
- Machine Learning Quick Primer (Code & Concepts) using TensorFlow for Java, Tribuo, DJL and PyTorch for Java
- Use Case Deep Dive : Learn how to take pre-trained ML model and deploy it using micro-services architecture (Micronaut framework) on the Cloud
The talk will be hands on with a mix of presentation and live coding. All the code will be available on GitHub after the presentation.
Java developers know that writing correct concurrent programs is hard. We have to prevent race conditions and deadlocks all while delivering the high performance that motivated us to move from a single-threaded environment to a multi-threaded one in the first place.
ZIO is a library for concurrent programming in the Scala programming language. While ZIO leverages the unique features of Scala the core idea of ZIO is independent of language: higher level concurrency operators can allow ordinary developers to quickly build complex, correct concurrent programs.
In this talk participants will see what some of these higher level concurrency operators look like, how they can use them in their own code, and how they can be implemented in any JVM language.
The foundation of programming which many of us have used for 20 years is evolving into something new. Concepts including immutability, functions, ADTs, & pattern-matching are helping us solve problems more reliably, understandably, and quickly. This session will help you understand these evolutions.
This session is a must for any Java developer under the pressure of high-performance expectations and tight deadlines in a cloud-native architecture. To that end, we have learned to make use of a variety of tools and abstractions to help move us along the path to production quickly and effectively. There is a rapidly and continuously evolving ecosystem that sustains the forward march of microservice architectures and their deployments. But, there's a dark side to using these tools in a rush to the finish line. Without taking a step back to understand what's happening below the surface, we can find ourselves stumbling in areas concerning quality, efficiency, and even security.
For many of us, the first step was to simply get our Java application up and running as expected within a container, and Docker was our tool of choice. Now it's time to review what you have implemented and make some improvements. Containerizing our Java applications is fairly straightforward with the latest container aware versions, but there are still pitfalls that can trip you up if you don't know where to look. This session will dive into the best practices of packing your Java container images efficiently and effectively for the trip to production. You will learn valuable information about cloud-native tools available today for building and running containers (including Docker alternatives), container image formats, image storage concerns, and common gotchas to avoid.
This year Java will celebrate it's 25th birthday. Such an anniversary milestone is no easy feat. Keeping Java a favorite choice for millions of developers has not happened by accident; rather it's through the continual careful stewardship, addressing ongoing challenges and evolving developer expectations, that keeps Java vibrant. Good stewardship doesn't only mean having a compelling technical roadmap — it also means keeping the community and ecosystem vibrant. Not all of it is obvious and not all rumors are true; this talk will shine a light onto what the Java team at Oracle has done for us (the community and ecosystem), lately, in OpenJDK and beyond. What has Oracle ever done for Java that will keep Java going for the next 25 years and beyond? Come attend to learn how to separate fact from fiction. This session also answers questions about why and how to participate in the evolution of the Java platform. Attendees will learn about the global programs and how they can participate in contributing to the future of Java as an individual, a corporation, or nonprofit.