Kuberntes and Java. How to do it correctly + Q&A session
Duke’s Star Trek with Java 14 Code Challenges
Duke needs your help in navigating through the Delta Quadrant. Join us on this incredible journey visiting new features of the JDK 14 system as well as the best features of previous versions of Java. During this journey, you can improve your craft as an engineer. These short challenges will keep your katas going at warp speed! Solve the puzzles to learn the full power of the Java language. Apply the techniques, and develop concise code where bugs will have a hard time hiding. Come to this session to boldly go where no Duke has gone before!
Controlling your race with Micrometer, Spring Boot (2.x) and Cloud Foundry
Imagine that you’re part of a (car) race team. You’re the one behind the screens to control the race and make some tough decisions (like changing the teams strategy).
But you don’t have the insights (or metrics) about your car, opponents or even the weather. Sounds painful right? But why are we making this mistake when building our software? Why don’t we implement metrics by default?
SLFf4J logging is one side of the story, but we also need to know our application health. That’s where Micrometer comes in! It’s a library which you can use to define your own custom metrics, like: - timers (to check the performance of your microservices) - counters (to check how many times a certain event is occurring) - gauges (to check the current value of a variable) - and many more These metrics are exposed by REST endpoints (JSON) together with Spring Boot actuator, which can be saved into a database like Prometheus or Graphite. And to visualize the data you can use a tool like Grafana. Pretty interesting right?
In the demo (live coding!) I will show you how to create such applications using Micrometer, Spring Boot and Cloud Foundry as our platform. Ready to win this race with me? Jump in!
Optimize your applications to the max with Jakarta EE and MicroProfile
When using complementary tools for optimal utilization in containers and scalable infrastructures, you can achieve optimal value when developing and running enterprise software. This applies whether you are building monoliths, microservices or anything in between.
Jakarta EE’s programming model and application server runtimes are a perfect fit to achieve this goal, especially when complemented with Eclipse MicroProfile. In this talk, I will explain how to tailor and optimize such enterprise applications to the max in order to achieve optimal value and development experience. I will also compare some key concepts with competitors like Spring Framework to emphasize the benefits and downsides.
Effective Spring + Kubernetes
Both Spring and Kubernetes have massive ecosystems leading to lots of ways to use Spring on Kubernetes. Which way is the best, what are the pros and cons of different approaches to using Spring and Kubernetes. This talk is organized as a series of recommendations for how to best use Spring and Kubernetes together in the Style of the Effective Java book. We will cover the things you should do with Spring and Kuberentes along with common mistakes and pitfalls.
MicroProfile Reactive Messaging: reaching Flow State
The joy of coding, when you get this happy feeling that life's amazing, everything just works and nothing can stop you anymore. A day to remember, when you were writing code and everything looked great, concise and beautiful. Come and take a deep dive with me into MicroProfile Reactive Messaging and see how we can reach Flow State again: it's awesome!
Humane theory defined four triggers that can help to achieve flow state: eliminate distractions, work on a specific task with a clear outcome, strategically consume caffeine and ensure that you're sufficiently hydrated. In this presentation I will explain how these triggers apply to Reactive Messaging, why you should move away from imperative messaging and how this will bring you into Flow State.
A Change-Data-Capture use-case: designing an evergreen cache
When one’s app is challenged with poor performances, it’s easy to set up a cache in front of one’s SQL database. It doesn’t fix the root cause (e.g. bad schema design, bad SQL query, etc.) but it gets the job done. If the app is the only component that writes to the underlying database, it’s a no-brainer to update the cache accordingly, so the cache is always up-to-date with the data in the database. Things start to go sour when the app is not the only component writing to the DB. Among other sources of writes, there are batches, other apps (shared databases exist unfortunately), etc. One might think about a couple of ways to keep data in sync i.e. polling the DB every now and then, DB triggers, etc. Unfortunately, they all have issues that make them unreliable and/or fragile. You might have read about Change-Data-Capture before. It’s been described by Martin Kleppmann as turning the database inside out: it means the DB can send change events (SELECT, DELETE and UPDATE) that one can register to. Just opposite to Event Sourcing that aggregates events to produce state, CDC is about getting events out of states. Once CDC is implemented, one can subscribe to its events and update the cache accordingly. However, CDC is quite in its early stage, and implementations are quite specific.
In this talk, I’ll describe an easy-to-setup architecture that leverages CDC to have an evergreen cache.
10 lessons learned from using Kafka in more than 1000 microservices
Kafka is the bedrock of Wix's distributed microservices system. For the last 5 years we have learned a lot about how to successfully scale our event-driven architecture to roughly 1400 microservices. We’ve managed to achieve higher decoupling and independence for our various services and dev teams that have very different use-cases while maintaining a single uniform infrastructure in place. In this talk you will learn about 10 key decisions and steps you can take in order to safely scale-up your Kafka-based system. These include: * How to increase dev velocity of event driven style code. * How to optimize working with Kafka in polyglot setting * How to support growing amount of traffic and developers. * How to tackle multiple DCs environment."
OpenTelemetry for Java Developers
You are already using logs and metrics to monitor your applications. Now you keep hearing about OpenTelemetry (or it's older sibling OpenTracing), ? This talk gives a hands-on overview of:
* What you can (not) do with OpenTelemetry. * How you can easily add it to your Java applications. * What the OpenTelemetry landscape looks like today and where it might be headed.
The demo is using the open source Elastic APM agent with its brand new OpenTelemetry integration.
Why you’re getting understandability wrong
Understandability is the most important concept in software, that most companies today aren’t tracking. Systems should be built and presented in ways that make it easy for engineers to comprehend them; the more understandable a system is, the easier it will be for engineers to change it in a predictable and safe manner. But with the rise of complex systems, it’s become all too common that we don’t understand our own code once we deploy it.
To deal with system complexity, developers are spending too much time firefighting and fixing bugs. In recent surveys, most devs say they spend at least a day per week troubleshooting issues with their code (sometimes, it can be a couple of days up to a full week trying to fix an elusive bug). This is hurting developer productivity and business results. It also creates a tough choice between flying slow or flying blind; as developers, we are too often making decisions without data in order to maintain velocity.
In this talk, I’ll highlight the importance of Understandability and how it has a huge impact on our day-to-day work. I’ll also discuss how it relates to popular concepts such as complexity, observability, and readability. Finally, I’ll share some tools and techniques to manage and optimize Understandability.
Testcontainers: A year-in-review
Unit testing is fine, but without proper integration testing, especially if you work with external resources like databases and other services, you might not know how your application will actually behave once it has been deployed to the real production environment.
Before Docker, configuring the environment for integration testing was painful – people were using fake database implementations, mocking servers, usually it was not cross-platform as well. However, thanks to Docker, now we can quickly prepare the environment for our tests. In this talk I would like to show how you can use Testcontainers ( https://github.com/testcontainers/testcontainers-java ) – a popular JVM testing library that harnesses Docker to easily, reliably, spin up test dependencies.
As a special focus we want to have a deeper look at the development and the addition of new features to the Testcontainers library in the last year. But that’s not all, we will also share an outlook at the horizon of the future of Testcontainers and might even get a glimpse at some brand new features that are currently in active development.
Come and learn why Apache, Spring, ZeroTurnaround, JetBrains, Playtika, Zipkin and others already decided to use Testcontainers for their integration testing needs!
How JSR-385 Could Have Saved the Mars Climate Orbiter
In 1999, NASA lost the $125 million Mars Climate Orbiter as it went into orbital insertion. Due to a mismatch between US customary and SI units of measurements in one of the APIs, the spacecraft came too close to the planet, passed through the upper atmosphere and disintegrated. Sadly, this hasn’t been the only instance where a mismatch between units of measurements had catastrophic consequences, but it’s certainly one of the most spectacular and expensive ones.
How could this happen? The bad news: if you use primitive types to handle quantities in your code, due to the same practice at best, you’ve codified the unit in a variable name or database field, e.g. calling it lengthInMetres. Otherwise, you’re only relying on convention, just like Lockheed Martin and NASA did.
Join this talk to learn how JSR 385 can help you avoid $125 million mistakes, how it applied the 2019 redefinition of SI base units, and discover the immeasurable world of dimensions, units and quantities.
Java Modules in practice with Spring Boot
Java Modules have been around for a little while now and most of us know deep inside that we need to start doing something with them. Yet most developers are waiting for the momentum to take off. You've probably heard the theory a couple of times already, but putting it into practice sounds like mummy forcing you to eat your veggies. Actually I love my veggies, so I’ll gladly help you out here. In this session I will demonstrate how you can start using the power of modules in your own application. A Spring Boot application. Because despite the adoption in libraries is not yet great, you can already perfectly make your own application modular. I will guide you through a step-by-step approach to making your application modular. No magic or module-fu is required to achieve this result. Just everyday technologies we have at our disposal in the Java ecosystem. And as a bonus, it even works with Kotlin.
Containers & Java: What I wish I had been told
Containers are nowadays more than a cool new tool to play with. They simply revolutionized the way we develop, architect and ship our softwares and become part of our day to day operations. On the other hand, Java has been around for more than 2 decades now, dominating the entreprise world. Both advocate the “RUN anywhere” principal! But, is it that easy ? No! Your perfect working local container, will, most probably fail on production because of MEMORY &/or CPU issues, since jvm apps assume they OWN the server they are running on.
In this session, will look at the gotchas of running JVM apps in containers & how to avoid costly pitfalls. What updates Java 10 brought to the table to improve container awareness. What are the issues related to prior versions and how to address each one of them to avoid the mess.
We will also highlight some tricks to obtain smaller images & best practices while writing your DockerFiles, showcase some plugins to helps none containers expert to integrate docker in their development process. We’ll finally introduce the concept of “Distroless” Docker Images and how to benefit from it."
Demystifying Garbage Collection in Java
This talk is meant to demystify how garbage collection (GC) works in a Java runtime. The beginning of the talk will be focused on what GC is and how it is useful for the lifetime of a program. After laying out the basics I’ll explain how each GC algorithm work and how they can be implemented in a real world JVM (e.g. OpenJ9, Hotspot). How are these algorithms put together to make up a good GC configuration, and how one can better select a configuration/policy for their application? These are some of the questions that I will be addressing during this talk. I will do so by tying these algorithms to OpenJ9 GC policies and compare them to other policies such as G1, ZGC and Shenandoah. Different programs have different behaviours; by using the more appropriate policy for your application, it can improve its performance considerably. By the end of the talk you will have a better understanding on how the JVM manages its memory and be able to choose the more appropriate GC policy for your application.
Architecting Cloud Computing Solutions with Java
Cloud-Native has become a big buzzword around the world, a term that is practically used by everyone at all times. But what does it mean? What are the advantages it brings to your application and your day as a software developer or architect? What's new in the Java world, and what are the steps to follow for a native cloud application? This presentation is a step-by-step guide that will practically guide you through implementing Cloud computing services effectively and efficiently.
Rediscovering the Value of Apache Kafka® in Modern Data Architectures
The use of distributed streaming platforms is becoming increasingly popular among developers, but have you ever wonder what exactly this is? Part Pub/Sub messaging system, partly distributed storage, partly event processing engine, the usage of this type of technology brings a whole new perspective on how developers capture, store, and process events. This talk will explain what distributed streaming platforms are and how it can be a game changer for modern data architectures. It will be discussed the road in IT that led to the need of this type of plataform, the current state of Apache Kafka, as well as scenarios where this technology can be implemented.
Hot Database Connections for Serverless Functions
Serverless functions might make database access. Database connection creation and tear down cost hundreds of milliseconds depending on your DBMS environment. This problem is exacerbated with Serverless functions that are are short-lived and cannot afford such cost on every call. As connections cannot be pooled across containers, this session presents techniques and best practices for: (i) avoiding connection creation and tear down; (ii) sustaining auto-scaling and high concurrency that is thousands of concurrent Serverless functions calls, in the face of a fixed number of database connections.
Camel K is Serverless
Can I work with a portable serverless framework? Yes you can! Apache Camel K is a lightweight integration platform, born on Kubernetes, with serverless superpowers. In this session we will talk about the need to make a difference of what is function-as-a-service and what is serverless and we will cover why both playing together are great for development.
The Effective Developer - Work Smarter, Not Harder
We’re agile, we’re doing DevOps, we work in cross-functional teams, and we use the latest developer pipeline tooling. With all those methodologies and technologies we should be highly effective, right? Probably not. Most of us still struggle with balancing coding speed and quality, working on the stuff that really makes a difference, and feeling constantly stressed by all the things we should learn.
Effective developers don't just write clean, simple, and robust code. They also have a strong understanding of the entire development process and the problem that needs to be solved. They take time to learn, practice, and play.
Learn how those developers build effective coding habits, think about the outcome first, reserve time for deep work, and much more. You’ll walk away from this talk with lots of ideas on how to work smarter, not harder.
Event Sourcing - what could possibly go wrong?
Yet another presentation about Event Sourcing? Yes and no. Event Sourcing is a really great concept. Some could say it’s a Holy Grail of the software architecture. I might agree with that, while remembering that everything comes with a price. This session is a summary of my experience with ES gathered while working on 3 different commercial products. Instead of theoretical aspects, I will focus on possible challenges with ES implementation. What could explode (very often with delayed ignition)? How and where to store events effectively? What are possible schema evolution solutions? How to achieve the highest level of scalability and live with eventual consistency? And many other interesting topics that you might face when experimenting with ES.
for Junior Java developers entry-level content.
10:00 — 10:05
10:00 — 10:05
The Intro to the Java Global Summit
10:05 — 10:15
10:05 — 10:15
Opening Program Commitee Members/Sponsors/Partners
10:15 — 11:00
10:15 — 11:00
Let's make a contract: the art of designing a Java API
Let's make a contract: the art of designing a Java API
An API is what developers use to achieve some task. More precisely it establishes a contract between them and the designers of the software exposing its services through that API. In this sense we're all API designers: our software doesn't work in isolation, but becomes useful only when it interacts with other software written by other developers. When writing software we're not only consumers, but also providers of one or more API and that's why every developer should know the features of a good API. During this presentation we will go through real-world examples, also taken from the standard Java API, of good and bad API and comment them in order to show the dos and don'ts of API design. More in general we will discuss the characteristics of an easy and pleasant to use API, like consistency, discoverability and understandability, together with some basic concepts like the principle of least astonishment, and find out how to achieve them.
Project Loom? Better Futures? What’s next for JVM concurrent programming
Project Loom’s goal is to bring light-weight threads and continuations to the JVM. Meanwhile, Kotlin’s coroutines have a well established position. Scala continues to improve on actor systems, and boasts a rich ecosystem of functional concurrency toolkits. In Java, programming using `CompletableFuture`s is becoming the norm. The JVM concurrency scene is getting crowded! This brings the question: what’s next? What are the problems that need to be solved? How can Project Loom disrupt the status quo? Will `Future`s still have a role to play in a post-Loom JVM? In the talk we will explore the changes that project Loom aims to bring to the JVM. We’ll see which problems are solved by virtual threads, and which problems remain. We’ll also try to speculate how Loom might impact the way we do actor programming, how to orchestrate concurrent process, and what kind of abstractions might supersede `Future`s. Finally, we’ll discuss interruptibility, why it might be useful, and what kind of additional challenges this brings. Come and see what’s next for concurrency on the JVM!
Live hacking: Breaking into your Java web app
In this session, we will demonstrate how common vulnerabilities in the Java eco-system are exploited on a daily base by live hacking real-world application libraries. All the examples used are commonly known exploits, some more famous than others, such as Apache Struts and Spring break remote code execution vulnerabilities. By exploiting them and showing you how you can be attacked, before showing you how to protect yourself, you will have a better understanding of why and how security focus and DevSecOps is essential for every developer.
Let’s have some Effective REST
Developers creating websites and especially backend developers need to know how to build RESTful APIs correctly and effectively. As nowadays those APIs is serving many channels either it is Mobile, Microservices components, IoT, integration or all of them. This session will help you plan and model your own APIs and understand the six REST design constraints that help guide your architecture. I will start with a simple overview, including advice on identifying the users or "participants" of your system and the activities they might perform with it. I'll help you to paper test your model, validating the design before you build it, provided with a live example to clear up the concept. You'll then explore the HTTP concepts and REST constraints needed to build your API.
Be productive developer with Kubernetes and Skaffold
Kubernetes and containers are great, however it may steal some productivity from the developers. Endless loop of "create and ship" containers on every code change, remote debugging and configuration management overhead and other challenges. Over the last years our team have collected best practices and recipes for the developers and try to bring remote Kubernetes experience as close as possible to the IDE and local development. This session will share DevOps tooling, recipes and configuration snippets and some coding with productivity modern tools like Skaffold.
Writing queryable APIs with MicroProfile GraphQL
GraphQL is a data query language developed internally by Facebook in 2012 before being publicly released in 2015. It provides an alternative to REST and ad-hoc web service architectures.”
In this talk, we will * Go through the basics of GraphQL * Discuss the differences with REST * Discuss the features in the current and future MicroProfile GraphQL API * Go through a basic example in Java using Quarkus.
We will look at the following GraphQL concepts: * Query * Fragment and Named * Filtering * Variables * Mutation * Error Handling * Introspections
Building a cloud-friendly application
The days of hand-crafted artisanal servers are long over. Modern web applications need to be able to run on many different servers without code changes. Not just different hosting providers, but different environments on the same hosting provider. Whether you're using a legacy dev/stage/prod setup or a modern branch-is-environment host, modern hosting imposes some requirements on your application design but also offers a huge potential for new and powerful tools.
In this session, we'll explore some key guidelines for building a cloud-friendly application, as well as look at some architectural options that a modern hosting platform enables.
2020 - A space odyssey with Micronaut and Quarkus
Last year, two contenders have decided to go on an ambitious mission and compete with Spring Boot as the fastest microservice framework in Java space! Now the battle is on, but Developer productivity is ruled by more than speed alone…
In this session I will discuss Micronaut, Quarkus and compare them with their cousin Spring Boot, who has been travelling the Java space since time immemorial. The question is: who can accelerate and adapt fast enough to outperform the others? Who will fail or prevail? Together, we will find out…
Optimization AI in Java, made easy with OptaPlanner
In this session, I will show how to schedule a school timetable using OptaPlanner. Let's prepare for the next school year in a couple of seconds!
OptaPlanner is the open-source AI constraint solver that optimizes planning and scheduling problems, which integrates well with Quarkus and Spring Boot. It can be used to solve problems such as the vehicle routing problem, employee rostering, maintenance scheduling, task assignment, school timetabling, cloud optimization, conference scheduling, job shop scheduling, bin packing, and other NP-hard problems.
By optimizing such problems with OptaPlanner, some companies save hundreds of millions of dollars and millions of kilograms of CO² emissions per year.
It can help you solve your problems, too.
Thirst-Quenching Streams for the Reactive Mind
This presentation will go into some details on how streams leverage on the underlying multicore processor to achieve parallelism. It will then explain the push vs the pull streaming model. It will then use a simple use case with code examples to illustrate the different API usages, as well as runtime processing analysis between a few popular Java implementations of Reactive Streams.
5 tips on how to deliver software effectively by aligning coding and business best practices
Have you ever played chinese whispers? After more than ten years of experience, I noticed that teams still unconsciously play this game during software development: the business team asks for something, that gets documented, and at the end gets delivered - unfortunatelly, not exactly like requested in a first place.
In this talk, we'll learn how to solve this problem once and for all, by aligning modern cloud-native architecture concepts with the usage of well-established business modeling standards.
By adopting five practical tips shared in this talk, you'll be able to increase developers' productivity and boost the communication between the technical and business teams.
With the support of a battle-tested open-source tool like jBPM, we'll learn how to break down the last wall of confusion between the business teams and the tech teams.
A Lesson from the Trenches: Making Dependency Management Secure
While Github Security Alerts and several other tools allow software developers to check free open-source dependencies of their projects, still little to no developers' attention is often given to their security. However, security vulnerabilities introduced by software dependencies might lead to severe incidents, like the Equifax breach, when the private data of more than 143 million people became publicly available due to a security vulnerability in an outdated software dependency.
In this talk, we will discuss the perceptions of developers coming from 25 companies located in 10 countries. More specifically, I will present the insights on the following developers' practices: - selection of software dependencies; - updating of software dependencies; - automating the dependency management process; - mitigation of bugs and vulnerabilities in dependencies, for which a fixed version does not exist.
I will then provide the analysis of each popular developers' practice and list their implications.
Hence, the key takeaways of this talk are the following: - participants will learn the current developers' practices of managing software dependencies; - participants will discover the implications of the most popular dependency management strategies; - participants will have the ideas on how to improve the dependency management of their software projects.
Serveless, beyond lambdas and functions
Serverless is one of the trending topics in the software industry and there is often confusion thinking about serverless as an programming model defined by functions deployed in different cloud vendor providers.
Serverless architectures go further, offering alternatives to design applications using third-party software "Backend as a Service" (BaaS) and custom code executed in ephemeral containers managed on platforms that support them "Functions as a service" (FaaS). It also includes IaaS and PaaS that is often ignored or not considered as it has to. This talk is about the evolution of different software architectures and related technologies to take advantage of this model to create modern architectures that reduce the time to market for software products.
From Sledge Hammer to Fine Brush for QA
What is the best approach to testing? It depends. If you have limited resources, you have to be smart. There is value in applying a fine brush to your verification efforts, however sometimes applying this finesse is difficult and time-consuming. Are there times to apply the sledge hammer? How do you minimize your susceptibility to gaps and risk? This presentation takes lessons from some large QA efforts, including those from open-source projects, to help you think about QA for any project, and what guidelines you can use to have a vibrant verification strategy.
Jakarta EE - Present and Future
Java EE has been re-branded to Jakarta EE and moved to truly open source governance under the Eclipse Foundation. This session overviews what this means, offers a brief tour of the first release - Jakarta EE 8, explores current state and looks to what the future might bring including some key challenges. We will also discuss how these challenges can be overcome through active community engagement.
The technical contents of Jakarta EE 8 is mostly the same as Java EE 8 - it solidly enables HTTP/2, Server-Sent Events (SSE), JSON and aligns the platform with Java SE 8. It includes a much awaited security API overhaul as well as a slew of critical updates to APIs like JSF, JPA, JAX-RS and CDI. The true difference is how Jakarta EE is evolved in the open.
You should come to this session with your thinking caps on and your sleeves rolled up. There is much to help move forward together that really matters.
Jakarta NoSQL: One API to many NoSQL databases into Cloud Native age
The next generation Database Management Systems do their best to be non-relational, distributed, open-source, and horizontally scalable. These banks are very easy and make any software engineer's job more comfortable, but the number of NoSQL databases are enormous! There are currently about three hundred non-relational databases, and that number keeps growing. The first question is: how to deal with so many databases? After all, there are several issues with this; there’s a learning curve for each new API, not to mention the vendor-lockin impact. Know more about the API that makes your life more comfortable to use NoSQL with Java at cloud-native age.
Change Data Capture with Apache Kafka and Debezium
Many growing organizations use Apache Kafka to address scalability concerns. When mixing microservices for data streaming and “database per service” patterns, things get challenging. How can you avoid inconsistencies between Kafka and the database?
Change Data Capture, or CDC, is a software design pattern that monitors and captures row-level changes to a database table and passes corresponding change events to a data streaming bus. Applications can read these change event streams and access the change events in the order in which they occurred.
Join this session to learn how to use debezium for reliable microservices integration and solving typical event-driven microservices challenges such as gradually extracting microservices from existing monoliths, maintaining different read models in CQRS-style architectures, and updating caches as well as full-text indexes.
Top 10 reasons to learn Java now than ever
Java moves our world.
Java helps you to stay safe, connected with your friends and family, and grow every day - it is used by apps and applications on your phone or laptops, to the enterprise applications in the cloud. Think of any industry or technology, and you’ll see Java there, from banking, health, commerce, gaming, insurance, education to Quantum Computing, Artificial Intelligence, Blockchain, and many more. It is everywhere. A mature and trusted ecosystem, Java has adapted to the changing business needs over the years and is relevant and popular. As we celebrate 25 years of Java technology in 2020, let's pass the baton to the next generation.
In this talk, I will speak about what are the top reasons we should explore java, what are the things that we love about it, what are the job opportunities.
Evolution of java: from object orientation to reactive applications with Webflux
Let's talk about the principles of reactive programming and how Java has evolved since object orientation, the concepts of functional programming that started to come with Java 8 and how this led to the emergence of Webflux. And we will see an example of an API with Spring Webflux using the Reactor library and the asynchronous server Netty.
Do Developers Dream of Stateless Apps?
In Blade Runner by P. K. Dick, trained hunters had to retire problematic Androids. We, Developers, are similar to those hunters. Our job is to solve problems. State brings complexity and troubles. Getting rid of it is not always possible. How to make our stateful distributed system highly available?
It’s a story based on the experience that I gained while working on stateful distributed systems deployed in cloud environments (Azure, AWS). It includes what went well and what is more important, what went wrong. I’ll start with defining state and explain differences between stateful and stateless apps (it’s not so obvious!).
Then I’ll discuss the strategies that we can use in cloud environments to ensure high availability our or systems. We’ll go through scaling, multi-region deployments, and why sometimes we need to care where our machines are located.
In the third part of this talk, I’ll focus on tools that help us to deal with the state and their high availability features provided by cloud. I’ll show you the live demo of Azure SQL failover and compare it to Cosmos DB. I’ll also discuss Storage and Queues. Understanding the limitations of tools we use is as important as being aware of what happens under the hood. It is needed to build reliable architecture.
I’ll sum up the talk by explaining what is SLA and how to calculate it for your system (yes, there will be some math). So, are we problem hunters or we are haunted by problems? Join my presentation, make your system highly available and dream peaceful dreams.
Extending the API functionality of a blockchain node - Ardor
My talk will start with a quick introduction to blockchain technology to explain the basic concepts. Afterwards I will explain the REST API calls written in Java and how you can add a Java class to add your own API using the core Java API calls of the blockchain.
I will use IntelliJ and the Ardor platform (it is a Java open source blockchain)
Winter Is Coming: A Kotlin Microservice Without Spring
Spring Boot is a common way to start almost any back-end web application or REST API; but what if you'd prefer to go without Spring Boot and without Spring altogether? Is it possible at all, and more importantly, is it painless? We will work through a common example and see together. For this talk, a basic knowledge of Kotlin is preferred. After the session, I will share a link to the repository with all the relevant code, so you can fork it and play with it on your own.
Elasticsearch - Securing a search engine while maintaining usability
Elasticsearch - being an integral part of the Elastic Stack - is known for its full-text search and analytics ability.
Elasticsearch is running on tens of thousands of nodes world-wide, so despite all the functionality squeezed into new releases, we also have to think about security, all the time. This talk will cover different aspects of Elasticsearch, explain some features and (sometimes unpopular) decisions and the reasoning behind. This talk will cover:
The goal of this talk is not to show off Elasticsearch features. You start thinking about these non-functional requirements in your own applications as well!