Here you can find the sessions that I have presented at conferences like JavaOne, JFokus, Devoxx FR, Geecon or Java2Days. You can also find new ideas for sessions I’m working on. If you are looking for speakers for your conference or company, I’ll happily give any of these sessions to you. Feel free to contact me about it.
Five Ways to Not Suck at Being a Java Freelancer
Do you ever wanted to have a freelance experience, but don’t know how to get started? Do you think that becoming a freelancer is too much of a risk to trade with your stable job and steady income? Do you want to control and steer every aspect of your professional career without relying on someone else doing it for you? Maybe you feel unhappy with what you are doing and need a change? Or maybe you’re just adventurous enough and willing to try something different! Come to my lightning talk where I’ll discuss a few major points about doing freelance based on my own personal experience in the Java world, and hopefully, this will help you clear up your mind and make your own decision about trying to freelance someday.
Java EE 7 Batch Processing in the Real World
This talk will explore one of the newest API for Java EE 7, the JSR 352, Batch Applications for the Java Platform. Batch processing is found in nearly every industry when you need to execute a non-interactive, bulk-oriented and long-running operation task. A few examples are financial transactions, billing, inventory management, report generation and so on. The JSR 352 specifies a common set of requirements that every batch application usually needs like checkpointing, parallelization, splitting and logging. It also provides you with a job specification language and several interfaces that allow you to implement your business logic and interact with the batch container. We are going to demo a real-life example batch application, starting with a simple task and then evolve it using the advanced API’s until we have a full parallel and checkpointing reader-processor-writer batch. By the end of the session, attendees should be able to understand the use cases of the JSR 352, when to apply it and how to develop a full Java EE Batch Application.
The 5 people in your organization that grow legacy code
Have you ever looked at a random piece of code and wanted to rewrite it so badly? It’s natural to have legacy code in your application at some point. It’s something that you need to accept and learn to live with. So is this a lost cause? Should we just throw in the towel and give up? Hell no! Over the years, I learned to identify 5 main creators/enablers of legacy code on the engineering side, which I’m sharing here with you using real development stories (with a little humor in the mix). Learn to keep them in line and your code will live longer!
Development Horror Stories
We all enjoy to hear a good success story, but in the software development industry, the life of a developer is also made up of disasters, disappointments, and frustrations. Have you ever deleted all the data in production? Or maybe you just run out of disk space and your software failed miserably! How about crashing your server with a bug that you introduced in the latest release? We can learn with each other with the mistakes we made. Come to this BOF and share with us your most horrific development story and what did you do to fix it.
Java EE 7, what’s in it for me?
The latest version of the Java EE platform had three major goals. First, improve developer productivity by introducing more annotations and removing boilerplate code to simplify integration with the platform. JMS 2 is the perfect example; Second, add first-class support for web standards, including a new API to build WebSockets, a new API to parse, process and generate JSON and a new Client API in JAX-RS 2 to invoke RESTful services; Third, meet the enterprise demands. The long-awaited Batch Processing API is now available to build batch processing applications using all the capabilities of the platform itself. The Concurrency Utilities API provides you with asynchronous capabilities. This session will explore all the new features introduced in Java EE 7 and share information to learn, develop and contribute.
Maven – Taming the Beast
Love it or hate it (and a lot of people seem to hate it), Maven is a widely used tool. We can consider that Maven has been the de-facto standard build tool for Java over the last 10 years. Most experienced developers already got their share of Maven headaches. Unfortunately, new developers are going through the same hard learning process, because they don’t know how to deal with Maven particularities. “Why is this jar in my build?”, “I can’t see my changes!”, “The jar is not included in the distribution!”, “The artifact was not found!” are common problems. Learn to tame the Maven Beast and be in complete control of your build to save you countless hours of pain and frustration.
Migration tales from Java EE 5 to 7
Are you still stuck in Java EE 5? Eager to move and boost the developer productivity with all the cool things introduced in Java EE 7? Join us to hear some of the solutions we had to implement to completely migrate an application called Segurnet from Java EE 5 to Java EE 7. Expect a very technical session where we are going to look into the details.Segurnet is a platform held by APS (Portuguese Insurance Association) that serves as an integrated network for the Insurance sector in Portugal for the last 20 years, with other 33 thousand active users.
Java EE 7 meets Java 8
The last few years have been pretty exciting for Java with new versions of EE and SE platforms. Java EE, introduced a new API to build WebSockets; a new API to parse, process and generate JSON; a new Client API in JAX-RS to invoke REST services, and finally the Batch Processing API to build batch applications. Java SE brought us the long-awaited Lambda expressions; the powerful Streams API to perform operations like filtering, mapping or sorting in a very easy and fluent way, and a brand new Date Time API, to deal with the complexities of Timezones and Periods. This session will combine all of these elements together and show you how to easily develop an application using Java SE 8 with Java EE 7, with live coding and samples.
Cluster your MicroProfile Application using CDI and JCache
Microprofile is a new platform definition that optimizes Enterprise Java for a Microservices Architecture and delivers application portability across multiple runtimes. You can use a subset of the Java EE specifications to develop Microprofile applications, with JAX-RS, CDI, and JSON-P. Now you need to make it highly available and scalable across a large number of machines. The session will feature a live coding demo where we will turn this Microprofile application, into a fully clustered application using only standard Java API’s. Finally, to show you how light it is, we will run the entire cluster in a set up of Raspberry PI’s.
Baking a Microservice PI(e)
Imagine you have several microservices exposing REST APIs. Imagine now that these microservices are spread all over and need to talk to each other. Imagine that you have a nice user interface interacting with these APIs where you can authenticate. And now, imagine that all this runs smoothly.
In this Deep Dive session, Roberto and Antonio will build, step by step, a full microservice architecture (using Java and different frameworks). This session will answer these questions:
- How to build, document and deploy several microservices spread on different nodes (we use a Raspberry PI cluster because the Cloud is too expensive)
- How to make those microservices talk to each other (Consul for registry and discovery)
- How to scale up, down, and deal with network failures (Ribbon to the rescue)
- How to deal with high traffic (Hystrix, here you come)
- How to monitor this distributed system (ELK stack)
- How to centralize configuration (MicroProfile Configuration)
- How to authenticate and manage authorization with JWT (Tribestream Access Gateway)
- How to have a centralized nice looking entry point (with Angular)
Lightweight Enterprise Java with MicroProfile
I laugh at people that tell me that Java is slow, heavyweight and cumbersome. Maybe it was true when we had EJB2. I will prove to you that we can develop Enterprise Applications with just a few lines of code that can run in a Raspberry PI. If it runs in a PI, I think we can safely say it would run anywhere! To be able to do it, I’m going to use a new platform called Microprofile. Microprofile optimizes Enterprise Java for a Microservices Architecture and delivers application portability across multiple runtimes. You can use a subset of the Java EE specifications to develop Microprofile applications, with JAX-RS, CDI, and JSON-P and later evolve it with Config, OpenAPI, Metrics, Tracing and JWTs. Join me for this live coding session and help me spread the word that Java is actually great for the Enterprise.
GraalVM and MicroProfile: A Polyglot Microservices Solution
Chasing the RESTful Trinity: Client, CLI, and Docs