João Esperancinha
Developer, Vereniging COIN
Nieuwegein, The Netherlands
Actions
João is a 10+ years experienced Software Developer, Studied Telecom Engineering at ISEL Lisboa, and worked in different companies in Portugal, Spain, and The Netherlands. He is a certified Kong Champion, a certified Java Developer (OCP11) and is a Certified Spring Professional 2021. Outside the software development Universe, João is someone interested in arts and crafts and making stuff out of old materials creating the occasional modified furniture. João loves plants and has a small potted garden with Yuccas and blueberry bushes. He has one particular YouTube channel called JESPROTECH dedicated to engineering where João shares his experience with the world.
Area of Expertise
Topics
Kotlin Mysteries found from years working with Kotlin
Kotlin can be very handy and easy to use. Kotlin offers the possibility to develop code that is easy to understand, safe, immutable, and thus predictable and follows standards that avoid side effects. I realized that very quickly after I started my Kotlin journey that already amounts to more than 4 years.
Having said that, some concepts can be difficult to visualize which can generate some confusion. While there are several advantages to using Kotlin, those advantages can only be put into practice if we can understand what the JVM is doing to our code. There are situations that may seem to question of non-nullable mark offered by Kotlin, others where you'll find functionalities that may seem to serve no purpose at first glance and if you are coming from the Java world you may find confronting the concept of specifically tail-recursive fuctions and its usages. All of these situations have created some confusing situations professionally, generating delays in development, that could have been mitigated if we had previous clear understanding of these concepts.
In this presentation, we are going to have a look at what tailrec, inline, crossinline, nullables, non-nullables do to our code, how the JVM responds to that, and how annotations affect behavior in the Kotlin code for web application services frameworks like the Spring Framework. We'll also have a look at what happens when a non-nullable becomes null in Kotlin and why that happens. You' ll leave this session with these mysteries behind you and ready to face the engineering world with Kotlin by your side whether you venture into android or server side development.
Presented at:
---
JNation 2025 - Coimbra - Portugal
Find all documentation over here:
Scribd: https://www.scribd.com/presentation/868098212/Decoding-Kotlin-Your-Guide-to-Solving-the-Mysterious-in-Kotlin-JNation2025
Slide Share: https://www.slideshare.net/slideshow/decoding-kotlin-your-guide-to-solving-the-mysterious-in-kotlin-jnation2025/279769739
SpeakerDeck: https://speakerdeck.com/jesperancinha/decoding-kotlin-your-guide-to-solving-the-mysterious-in-kotlin-jnation2025
The video recording of the presentation can be found here:
https://www.youtube.com/watch?v=V-byiwmUWd4
---
London Java Community Live User group Sessionize Event Upcoming
JNation 2025 Sessionize Event
DevoxxUK 2025
At DevoxxUK I presented: Could Virtual Threads cast away the usage of Kotlin Coroutines - DevoxxUK2025
This is an updated version of the original presentation I did at the LJC in 2024 at the Couchbase offices. This version, tailored for DevoxxUK 2025, explores all of what the original one did, with some extras. How do Virtual Threads can potentially affect the development of resilient services? If you are implementing services in the JVM, odds are that you are using the Spring Framework. As the development of possibilities for the JVM continues, Spring is constantly evolving with it. This presentation was created to spark that discussion and makes us reflect about out available options so that we can do our best to make the best decisions going forward. As an extra, this presentation talks about connecting to databases with JPA or JDBC, what exactly plays in when working with Java Virtual Threads and where they are still limited, what happens with reactive services when using WebFlux alone or in combination with Java Virtual Threads and finally a quick run through Thread Pinning and why it might be irrelevant for the JDK24.
Official presentation location and video:
Presentation: https://www.devoxx.co.uk/talk/?id=22669
Video: https://www.youtube.com/watch?v=Nik9AaVd2_M
The slides for the presentation are available in the usual channels:
Speakerdeck: https://speakerdeck.com/jesperancinha/could-virtual-threads-cast-away-the-usage-of-kotlin-coroutines-devoxxuk2025
Scribd: https://www.scribd.com/presentation/859430026/Could-Virtual-Threads-Cast-Away-the-Usage-of-Kotlin-Coroutines-DevoxxUK2025
Slideshare: https://www.slideshare.net/slideshow/could-virtual-threads-cast-away-the-usage-of-kotlin-coroutines-devoxxuk2025/278906944
Kotlin London April @ M&S (Online)
Project Arrow may be unknown to some, but It is a project that covers many important aspects of functional programming to build resilient and performant services. I want with this talk to share my experience but instead of talking about Telecom, I want to include this talk in the context of a spaceship and data transmission throughout all the operating systems. I cannot of course show the code of any company I have worked for and so, to share my knowledge and experience I will create a spaceship scenario. For that, I will use the Ktor as an example for services completely implemented in Kotlin, with Exposed for database access and completely reactive. You should come out of this session knowing all the major aspects of Project Arrow, including foundation knowledge, some advanced features, and a few extras.
Meetup session:
https://www.meetup.com/kotlin-london/events/306456259/
The slides for my session are available here:
Scribd: https://www.scribd.com/presentation/846009877/Boosting-performance-and-functional-style-with-Project-Arrow-from-a-practical-perspective-with-Spaceships
Speakerdeck: https://speakerdeck.com/jesperancinha/boosting-performance-and-functional-style-with-project-arrow-from-a-practical-perspective-dot-dot-dot-with-spaceships
Slide Share: https://www.slideshare.net/slideshow/boosting-performance-and-functional-style-with-project-arrow-from-a-practical-perspective-with-spaceships/277622766
NLJUG (Netherlands Java User Group) Speaker Academy 2024 - Session II
C.R.a.C in Spring - I just froze my service!
Starting up complex enterprise Java applications may take a long time and you may not want to wait that long when scaling or deploying. Project CRaC, meaning Coordinated Restore at Checkpoint allows us to save the state of a service. It means that we can literally pause the runtime at a certain checkpoint and restore the service quickly at that point at any point in time.
For Spring services, we can pause them and safely perform updates to our cloud environment without the need to reinitialize them, because we can resume their runtime after the checkpoint.
In this session I will show my experience with Project CRaC, what it means to pause a service, and how to manage the generated files and state. You'll leave this session knowing that there is yet another alternative for startup times beyond GraalVM or other native compilation solutions, which will empower you to make even better decisions for your project
At the speaker session, the whole session had to be reduced to 15 minutes, turning into a short reflection about the potential usage of it and how to use it from a technical perspective.
The session is available on two document repositories:
- Scribd: https://www.scribd.com/presentation/783555869/C-R-a-C-in-Spring-I-froze-my-server-15-minute-session-for-NLJUG-speaker-academy
- Slide-share: https://www.slideshare.net/slideshow/c-r-a-c-in-spring-i-froze-my-server-15-minute-session-for-nljug-speaker-academy/272673111
Meetup London Java Community (LJC)
My presentation was incorporated into a two-presentation Meetup session at the London Java Community group at the Couchbase Headquarters in 55 King William Street.
Title: Could Virtual Threads cast away the usage of Kotlin Coroutines? What experience can tell us:
How do Virtual Threads can potentially affect the development of resilient services? If you are implementing services in the JVM, odds are that you are using the Spring Framework. As the development of possibilities for the JVM continues, Spring is constantly evolving. This presentation for the London Java Community (LJC) was created to spark that discussion and makes us reflect about out available options so that we can do our best to make the best decisions going forward.
There are no videos, or photos available for the event, but I did make a video with an extended version of that presentation. I talk about these topics in a very casual way and I also explain why and how the tests were performed:
- https://youtu.be/SNocP3qWOHs
Documentation on Scribd:
- https://www.scribd.com/presentation/768072685/Could-Virtual-Threads-Cast-Away-the-Usage-of-Kotlin-Coroutines
- https://www.slideshare.net/slideshow/could-virtual-threads-cast-away-the-usage-of-kotlin-coroutines/271727680
More info on the event:
- https://www.meetup.com/londonjavacommunity/events/302808393
- https://www.eventbrite.co.uk/e/ljc-meet-up-tickets-988279208717
Kotlin MeetUp Amsterdam @ JetBrains! Kotlin Notebooks, Decoding Kotlin & more!
My presentation was incorporated into a 3 presentation Meetup session. The name for that session was: "Kotlin MeetUp Amsterdam @ JetBrains! Kotlin Notebooks, Decoding Kotlin & more!"
The full video of my presentation can be found here. It was kindly given to me by the NLKUG team later on:
https://www.youtube.com/watch?v=MbN_wys2lOQ
Title: "Decoding Kotlin - Your guide to solving the mysterious in Kotlin" - This was my session on this meetup at the JetBrains offices about 5 curiosities about the Kotlin programming language. I have a made a post event video about it. It is not a video of the event, but it is a video about the event and about the topics of the event:
https://www.youtube.com/watch?v=CrCVdE2dUQ8
The documentation about this talk is available here:
Scribd: https://www.scribd.com/presentation/726367924/Decoding-Kotlin-Your-Guide-to-Solving-the-Mysterious-in-Kotlin
Speakerdeck: https://speakerdeck.com/jesperancinha/decoding-kotlin-your-guide-to-solving-the-mysterious-in-kotlin
Open Hack Night #21: Reactive programming in Spring Webflux @ Eonics
In this session I have discussed reactive programming with WebFlux. The slides are available here:
Scribd: https://www.scribd.com/presentation/709501358/Reactive-Programming-With-Spring-Webflux-Eonics-Hack-Night-21
Slide-share: https://www.slideshare.net/slideshow/reactive-programming-with-spring-webfluxpptx/266559708
Speakerdeck: https://speakerdeck.com/jesperancinha/reactive-programming-with-spring-webflux-eonics-hack-night-number-21
Meetup: https://www.meetup.com/eonics-open-hack-night/events/268235492/
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top