DevCon Live represents a powerful tool of learning sessions lead by experts for experts from the tech
industry. Check the Agenda, find your perfect mix of events, and craft your own journey with the most
important topics of the moment!
Microservices and big-data increasingly confront us with the limitations of traditional input/output. In traditional IO, work that is IO-bound dominates threads. This wouldn't be such a big deal if we could add more threads cheaply, but threads are expensive on the JVM, and most other platforms. Even if threads were cheap and infinitely scalable, we'd still be confronted with the faulty nature of networks. Things break, and they often do so in subtle, but non-exceptional ways. Traditional approaches to integration bury the faulty nature of networks behind overly simplifying abstractions. We need something better.
Spring Framework 5 is here ! It introduces the Spring developer to a growing world of support for reactive programming across the Spring portfolio, starting with a new Netty-based web runtime, component model and module called Spring WebFlux, and then continuing to Spring Data Kay, Spring Security 5.0, Spring Boot 2.0 and Spring Cloud Finchley. Sure, it sounds like a lot, but don't worry! Join me, your guide, Spring developer advocate Josh Long, and we'll explore the wacky, wonderful world of Reactive Spring together.
The aim of this presentation is to make API first easier to adopt. To accomplish this, we'll compare API first to Code first, on multiple dimensions, like ease of use and impact in the project. By the end we'll have recommendations on when to use each of them. All the information will be backed by examples, and the respective code will be available on github.
With Java 14 and 15 released recently, it is not simple to keep up with the new Java features. This talk will discuss the enhancements recently added to the Java platform, large and small. We will also touch on long-term, impactful, enhancements such as Project Loom and Project Panama.
Attend this session to understand what Java brings you in 2020.
Since 2017 we’ve decided to use Java Spring Boot as the main framework for developing APIs in BCR. From a couple of software engineers now we are organized as Digital Labs with more than 50 developers and still growing.
We’ll discuss what technologies and tools we are using and how we are evolving and trying to stay close to the proven trends in Java, focusing on the microservices architecture for our newest platform that we are building nowadays.
Head Of Digital Development Practices
When developing new features we often trust already existing part of application and we almost always believe that our networks, hardware and databases will work as expected without issues. Each case described in this speech is production incident that lead to data loss or inconsistency - from non-transactional http calls, to Kafka message loss and XDR-related issues.
In the last couple of years straightforward JVM GC tuning has become possible with a simple flow that anyone can follow. For most of the last decade GC tuning was arcane and fragile, but now the options are clearer and more targeted and there is a clear step-by-step procedure you can follow, which I detail in this talk.
Many times we find ourselves in the need of reacting to database changes and taking action depending on each case. While the use of triggers might be good enough initially, they tend to slow down the entire system when their number increases. But what about the binary log, a feature which sometimes people tend to leave behind?
During this presentation, you will understand how we can stream database changes using its binary log and also what tools allow us to interact with it and make our Java development lives easier. Of course, live coding examples and good humor will be provided “out of the box” during this talk.
You are also invited to take our technical keynote quiz, which will be active for only 2 hours, starting at 15.40 PM. The winners will be announced at 18.00 PM. You can win one of 1500 lei Emag vouchers or 3* 500 lei Emag vouchers. The Quiz is available here: http://www.quiz-maker.com/Q62FAFULL
Does your heart beat faster when you’re developing your Java application? Does
it spark joy when you’re coding? If not, then it’s time to leave some old ways
Join us on this live coding session and get familiar with Quarkus. You’ll learn
to love how your old and new favorite APIs will start in a matter of
milliseconds and consume tiny amounts of memory. Hot reload capabilities for
development will give you instant sparks of joy!
How can I test my microservices? It's an often heard question that leads to a lot of debate. Deployment and interdependence with other services are the challenges we're facing there. So, what if we could treat our microservices tests just like our familiar unit tests? What if we could isolate the microservice and mock all its dependencies?
With mock-server you can do just that. Mock-server lets you mock any http service, making you independent of other teams building those services. And the best part is, you can use it with the tools you already know like JUnit, Maven and Docker and do all the things you already know from your favorite Java mocking framework. You can run mock-server locally, as part of your Maven build or as a Docker image in your cloud environment. In this session I will show you exactly how you can use mock-server for your tests.
At a point in the past, it was forecast that Java would die, but the JVM platform would be its legacy. And in fact, for a long time, the JVM has been tremendously successful. Wikipedia itself lists a bunch of languages that run on it, some of them close to Java e.g. Kotlin, some of them very remote e.g. Clojure.
But nowadays, the Cloud is becoming ubiquitous. Containerization is the way to go to alleviate some of the vendor lock-in issues. Kubernetes is a de facto platform. If a container needs to be killed for whatever reason (resource consumption, unhealthy, etc.), a new one needs to replace it as fast as possible. In that context, the JVM seems to be a dead-end: its startup time is huge in comparison to a native process. Likewise, it consumes a lot of memory that just increase the monthly bill.
What does that mean for us developers? Has all the time spent in learning the JVM ecosystem been invested with no hope of return over investment? Shall we need to invest even more time in new languages, frameworks, libraries, etc.? That is one possibility for sure. But we can also leverage our existing knowledge, and embrace the Cloud and containers ways with the help of some tools.
In this talk, I’ll create a simple URL shortener with a “standard” stack: Kotlin, JAX-RS and Hazelcast. Then, with the help of Quarkus and GraalVM, I’ll turn this application into a native executable with all Cloud/Container related work has been moved to the build process.
Java is moving forward and faster than ever before. How do developers keep pace with what’s new in Java with its six-month release cadence?
Just knowing a feature is not sufficient. Join this live-coded session to stay ahead of the curve as Java adapts to the changing technology landscape and becomes more relevant than ever.
The audience will take away why, how, and where to use the new language features like Sealed Classes and Interfaces, Records, Text Blocks, Pattern Matching for instance of and much more that will transform your everyday coding experience. You’ll see for yourself if it is worthwhile adopting all these new features.
Spring Boot has revolutionized the Java space and continues to do so, evolving constantly to increase developers' superpowers and advance the state of production-grade software development.
Presenting a dynamic technology before vastly different audiences often limits what can be proposed & presented. Let’s fix that!
This session is an omakase, a "chef’s choice" of key points and latest/coolest capabilities for developers in the Spring Boot ecosystem. Known by French chefs as m’étonner ("Astonish me!"), the goal is to combine useful patterns and new possibilities in one fast-paced live-coding adventure from which everyone leaves with something tasty to chew on. Come for the apps, stay for dessert, leave satisfied & excited for the next "course" of production software!
One of the most
common approaches when designing loosely-coupled (micro)service architectures
is using a database per service. But given the fact that these services are
communicating asynchronously, how can we make sure that the data remains
consistent between all our systems?
Change Data Capture gives us a solution to
this challenge: it allows us to react to database changes (insert/update/delete
operations) of interest and propagate specific events to our event bus.
During this masterclass, we will be addressing
the following topics:
●how to implement this pattern
using open-source tools;
●advantages and disadvantages of
such an approach;
●different ways to further
improve our solution;
●other areas where CDC might
While this session will have its
examples and coding done in Java, the topics and challenges presented here are
generally applicable to distributed systems regardless of the language of
implementation. Minimal knowledge of microservice architectural patterns and
synchronous / asynchronous communication would ensure your best
You are also invited to take our technical Masterclass quiz, which will be active for only 2 hours, starting at 12:00 AM. The winners will be announced at 15.00 PM. You can win one of 1500 lei Emag vouchers or 3* 500 lei Emag vouchers. The Quiz is available here: http://www.quiz-maker.com/QC5DA57YQ
Open Bank Development is how we’ve named our internal
community that adopts open source technology stack. Started around Java Spring
Boot framework we evolved together with devops practices and frontend
development. Sample Lab it’s our blueprint for applying standards and practices
applied in an enterprise landscape. We invite you to deep dive in how we’ve put
together all the pieces that makes life easier for a Java engineer inside a Lab
Head Of Digital Development Practices
Reactive programming has been rapidly gaining popularity in the industry
lately. For a long time working with a database in a non-blocking,
backpressure-aware manner in Java was almost impossible.
A few years ago in order to solve this problem, R2DBC specification was created, which is based on reactive stream specification types and allows non-blocking, backpressure-aware database access. Since then an ecosystem has started to appear and evolve around it.
In this talk, I will show what R2DBC specification and the surrounding ecosystem can offer and share our experience of building a solution based on R2DBC and delivering it to the production.
Attila provides some of the lessons learned from adopting
Kotlin in backend applications. This talk lays out a clear path containing the
steps towards using Kotlin on your Java projects. Both tips and common hurdles
when migrating towards Kotlin are addressed.
When many of the
projects are Java, there are a few challenges to establishing a competent CI/CD
workflow. From the code-coverage (both with unit-tests and functional tests) to
building containers for multiple development/test/production systems, you need
the correct frameworks in place.
When, additionally, you're part of the telecom world, choosing the right technology is important to ensure a stable development baseline, for a longer period of time, able to provide the required stability and performance (tier 1, millions of end-customers, up-time in the high 9s, etc).