Here you can find the sessions that I have presented at conferences like JavaOne, CodeOne, Devoxx, Devoxx UK, Devoxx FR, DevNexus, JFokus, GeeCon, jPrime, JBCNConf and many more. 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.

Deconstructing and Evolving REST Security

The learning curve for security is severe and unforgiving. Specifications promise infinite flexibility, habitually give old concepts new names, offer endless extensions, and almost seem designed to deliberately confuse. With an eye on architectural impact, actual HTTP messages, and aggressive distaste for fancy terminology, this session delves into OAuth 2.0 as it pertains to REST and shows how it falls into two camps: stateful and stateless. It then explores a competing Amazon-style approach called HTTP Signatures, ideal for B2B APIs. Finally, it discusses a new internet draft launched this year that combines them both into the perfect two-factor system that could provide a one-stop shop for business as well as mobile REST scenarios.

GraalVM and MicroProfile: A Polyglot Microservices Solution

Microservices need to support many programming languages, requiring both a language-agnostic network protocol and a polyglot runtime environment. In addition, microservices written in one language may need to use APIs written in some other language. Using the MicroProfile conference sample architecture implemented as a polyglot solution (Java, JavaScript, Python) on GraalVM, this presentation demonstrates how MicroProfile JWT, MicroProfile Metrics, MicroProfile Rest Client, MicroProfile Health Check, and more can provide architecture-level interoperability across concerns. Attendees interested in creating a polyglot solution on GraalVM compatible with MicroProfile will get a demo-heavy introduction with occasional dives into the code and leave with read-to-run samples in GitHub.

Chasing the RESTful Trinity: Client, CLI, and Docs

Writing a truly consumable REST API is hard. Once exposed, documentation must be perfect before it can be consumed. Consumers often face days or weeks of work creating the client code. Many just need a command-line API. For a large API, writing these by hand and keeping them in sync is mission impossible. This session shows how to combine tooling around JAX-RS, OpenAPI, and MicroProfile REST Client to bootstrap microservice APIs that have Amazon-style Java client library, command-line API, and AsciiDoc/HTML documentation. The presentation explores the generation of clients in other languages such as JavaScript and Git-inspired command-line techniques that enable REST calls to be secured via SSH keys. All perfectly documented in AsciiDoc, HTML, and man pages.

From Zero to MicroProfile Hero: Let’s Dive into a Microservices World

We laugh at people who tell us Java is slow. The dark days of EJB2 are over. This tutorial shows you how to develop enterprise applications with just a few lines of code that can even run on a Raspberry Pi. MicroProfile optimizes Enterprise Java for a microservices architecture and delivers application portability across multiple runtimes. You can use a subset of Jakarta EE to develop MicroProfile applications, using JAX-RS, CDI, and JSON-P, and extend it with Config, JWT, Fault Tolerance, Health Check, Metrics, OpeanAPI, and OpenTracing. With live-coding examples, this presentation shows you how to get hands-on with MicroProfile and rediscover the pleasure of developing enterprise applications.

Quarkus in Real-World Deployments

Quarkus created quite a buzz in the enterprise Java ecosystem this year. Like all other developers, this session’s speakers were curious about this new technology and saw a lot of potential in it. They dived right in and started using it in one of their new applications. In this session, they show you how to use it to develop a microservice architecture by mixing technologies such as MicroProfile, Camel, InfluxDB, and RabbitMQ and deploy it with GraalVM and Kubernetes. Finally, they present a retrospective about adopting such a new technology, how they code, the main challenges they have faced, how the developer experience compares to other technologies’, what the community is like, and what the weakest points are.

Leave a reply

Your email address will not be published.

You may use these HTML tags and attributes:

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>