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.
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.
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
Blaming the Database / Myth vs fact / Classic ORM vs MyBatis
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.
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 prove useful.
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 experience.
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 at BCR.
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).