Dynamic Proxies in Java
Java frameworks often need to dynamically create classes. One approach to do that easily in Java is dynamic proxies. In this talk, we will show how they compare to hand-written classes. We will then examine how we can use dynamic proxies to reduce the amount of code that we have to write.
A Change-Data-Capture use-case: designing an evergreen cache
CDC is a brand new approach that “turns the database inside out”: it allows to get events out of the database state. This can be leveraged to get a cache that is never stale.
When one’s app is challenged with poor performances, it’s easy to set up a cache in front of one’s SQL database. It doesn’t fix the root cause (e.g. bad schema design, bad SQL query, etc.) but it gets the job done. If the app is the only component that writes to the underlying database, it’s a no-brainer to update the cache accordingly, so the cache is always up-to-date with the data in the database.
Things start to go sour when the app is not the only component writing to the DB. Among other sources of writes, there are batches, other apps (shared databases exist unfortunately), etc. One might think about a couple of ways to keep data in sync i.e. polling the DB every now and then, DB triggers, etc. Unfortunately, they all have issues that make them unreliable and/or fragile.
You might have read about Change-Data-Capture before. It’s been described by Martin Kleppmann as turning the database inside out: it means the DB can send change events (SELECT, DELETE and UPDATE) that one can register to. Just opposite to Event Sourcing that aggregates events to produce state, CDC is about getting events out of states. Once CDC is implemented, one can subscribe to its events and update the cache accordingly. However, CDC is quite in its early stage, and implementations are quite specific.
In this talk, I’ll describe an easy-to-setup architecture that leverages CDC to have an evergreen cache.
In-memory High-Performance-Persistence for the Core JAVA Dev
Small UseCases with a significant amount of data for internal company usage, most developers had this in their career, already. However, no Ops Team, no Kubernetes, no Cluster is available as part of the solution.
In this talk, I will show a few tech stacks that are helping to deal with persistent data without dealing with the classic horizontal scaling tech monsters like Kubernetes, Hadoop and many more.
Sit down, relax and enjoy the journey through a bunch of lightning-fast persistence alternatives for pure java devs.
Screen reader support enabled.
Integration Testing with Spring
Sick of mocks? Sick of testing such thin slices of logic that keep failing when put back together? Have you realized that end-to-end testing is what you want to do more often, but you are still concerned on how to make your tests reliable and fast? There's a place between class-unit-testing and end-to-end-testing, drawing advantages from both. That's where you want to be. But it requires support and deep understanding of the framework, in our case, Spring. Join this session and see several key testing tools when testing a Spring appplication:
@MockBean, test implementation and properties, Transactional Tests, MockMvc and a glimpse of WireMock. All in a lively, entertaining talk.
"nn" things every Java developer should know about AI/ML/DL
As a Java developer, to better myself, learn new and more interesting subjects and technologies, in this case in the areas of AI/ML/DL I have found that there is so much to know. Almost, ""nn"" things -- infinite number of them and constantly increasing by the day. During the session, I will show how I created my own order or list to overcome this problem and put them on this git repo https://github.com/neomatrix369/awesome-ai-ml-dl for everyone else to learn from. We actually have access to quite a lot of things we may not be fully aware of, let's see what they are and how we may be able to use (some if not all) of them to improve our knowledge.
To keep the session lively and interesting, I'll try to show a demo or two, and as takeaway share puzzles and thought exercises you could do on your own after the session is over.
Integrating software in an eight billion euro bank
Every large company is divided into smaller departments: HR, Facility Services, IT, Marketing and others.
These departments, somehow, acquire means to organize their department: they create software for their specific needs.
Unfortunately, this often leads to a mixed user experience: a tool to register illness, another tool to purchase hardware, yet another tool for instant messaging, etc.
By integrating many of these tools and processes, we wanted to increase the efficiency of the employees and .. to increase employee happiness.
In this talk, I will explain how we did this: with a focus on APIs, Consumer Driven Contracts and Event Driven Architecture using microservices on Kubernetes.
Expect lessons learned, best practices from our experience on the field.
Workshop: Empowering your software with Imagga’s image recognition technologies
In this workshop you will learn what image recognition is all about, how it works and how easily can it be incorporated in your projects using Imagga’s Cloud API. The workshop will cover two interesting topics in visual AI with hands-on examples - visual search and facial recognition.
After 8: Sweet New Features in the JDK
Six releases of Java in less than three years! Yes, the new fast cadence for the OpenJDK does work. Despite the short development cycle, the rate of change in Java is faster than it was before.
In this session, we’ll take a look at the rapid evolution of the Java platform with the introduction of new features in each of the recent releases:
• JDK 9: Java Platform Module System
• JDK10: Local variable type inference
• JDK 11: JDK Flight Recorder
• JDK 12: Switch expressions
• JDK 13: Text bocks
• JDK 14: Records and pattern matching for instanceof
We’ll also cover many of the smaller features that will make your life as a developer easier.
What might future JDKs include? To answer that question, we’ll explore some of the longer-term plans for Java, like project Amber, Loom and Valhalla.