Mr. Who? Besides one of my childhood heroes, Mr. Miyagi is a fictional karate master from Okinawa, Japan, in the movie serie ‘The Karate Kid’. He was the karate mentor of several people and made them worthy champions. I wanted that too! So began my own karate journey with my own sensei (mentor). Later, I became a lawyer and got a so-called ‘patroon’ (another mentor). Both mentor relationships have borne fruit. When I took my first steps in my career switch to the IT world, I discovered that mentorship is not a matter of course. What a pity! Fortunately, I managed to find one again. I experienced it as a difference as night and day.
I would like to talk about the mentorship’s “what”, “who” and “how”. I would also like to explain the importance of mentorship in our field and what it could offer us as a developers community. In doing so, I would like to share my own experiences and ideas. To add weight to it, I make a link with research. I have looked at whether I can find my own experiences and ideas back in society, science or both. I think that we as a developers community, but also as an employer and client, should not want anything else and I would like to explain why.
By 2022, IDC has predicted that 65% of the global GDP will be digitally transformed. Two-thirds of the products and services that you pay for will be driven by software, and the quality, cost and time to market of your software products will determine the fate of your business. There has never been a more important time to foster developer productivity, but many of our methods have not evolved.
In this keynote style talk you will learn why DPE is the most important development in the software engineering world since the introduction of Agile and DevOps concepts and tools. DPE is a new software development practice that uses acceleration technologies to speed up the software build and test process and data analytics to improve developer efficiencies by as much as 10x. The ultimate aim is to achieve faster feedback cycles, more reliable and actionable data, and a highly satisfying developer experience.
Justin Reock, Field CTO and Chief Evangelist at Gradle is pioneering DPE as a practice and set of technologies and is one of the world’s leading advocates. Specifically, Justin will provide an overview of the key concepts and tools, business impact on key business objectives like time-to-market, cost and quality, the business case for DPE, and the role of AI/ML in DPE moving forward.
Apache Kafka is the de-facto standard for high-performance data streaming applications. Such applications are infrequently about pure message processing. They often need to integrate Kafka messages with a remote endpoint, persist messages to a data store, or relay them to a third-party service.
This talk presents how Quarkus, in combination with MicroProfile Reactive Messaging, lets you build Kafka-based event-driven architectures. We will illustrate the concepts and common patterns using a sample application and show how Quarkus makes the development of event-driven microservices smooth and straightforward while integrating naturally with Quarkus' reactive core. Expect to see lots of live coding, showcasing live reload, Dev UI, continuous testing, etc.
"DevOps" is the operations people’s crafty plan to make developers do other people's work, but we are smart enough to see right through this naive rebranding trick!
Baruch suggests you think about it: we, the developers, have written all the code. It passes all the tests; it obviously works, and works well (Are we a little proud? We are!); so we are DONE.
Now, out of the blue, a bunch of "thought leaders" (all with an operations background, mind you!) are trying to tell us that we have to learn YAML, Docker, Kubernetes and Terraform to deploy our software because suddenly it is our concern?!
In this talk, we'll discuss why developers do or don’t need DevOps. We'll consider arguments made by DevOps visionaries and see whether they hold water. Hopefully, by the end of the talk, we'll understand whether DevOps really helps developers to deploy better code to production more often, or if it is just another scam made up by marketing and evangelists.
Diagrams as code is becoming a popular way to diagram software architecture, particularly for long-lived high-level documentation - write the diagram source in a text-based domain specific language (e.g. PlantUML or Mermaid) or a programming language, and render diagrams using web-based or command line tooling. The benefits are well understood - writing the diagram source as text allows for easy integration into software development practices and toolchains, plus the automatic layout facilities allow authors to focus on content. The problem with this approach is that it's easy for diagrams to get out of sync. Enter "diagrams as code 2.0" and the open source Structurizr DSL - a Java-based library providing a way to define a model of our software architecture and the views that we'd like to see, ultimately resulting in a consistent set of diagrams that are generated for us.
Duke needs your help in navigating through the Delta Quadrant. Join us on this incredible journey visiting new features of the JDK 17 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!
gRPC is a contract-first, high performance communication protocol which makes it possible to efficiently connect services implemented using various languages and frameworks.
With Quarkus you can easily expose and consume gRPC services, effortlessly test the services by using auto-configured clients, and manually test your work with the Dev UI.
This talk will introduce gRPC, discuss when to use it (versus REST) and show how to use it with Quarkus.
We often make applications in which REST (HTTP) predominates, but is this a smart choice? Can't it be faster, or rather asynchronously and event based? Especially if you work with BIG DATA, Kafka is usually the better option. You get a whole platform where scalability, fault tolerance and replay-ability are very important (you don't want your message to be lost, and preferably you want to process it again if your system has been down).
There are three libraries we will discuss during live coding:
- Spring Kafka, where we will create a consumer and producer and test them with test-containers (without starting a whole cluster yourself).
- Kafka Streams, a perfect fit for functional programming! With the StreamsAPI we will cover the best and most used patterns like branching, joining, mapping and more. We will create a Topology (stream) where we will handle fraud detection.
- Spring Actuator is a match when you want to monitor your stream of events, you already got a lot of metrics for free!
After the session you can create your own application with consumers, producers and streams!
When it comes to distributed, event-driven messaging systems, we usually see them supporting either one of two types of semantics: streaming, or queueing, and rarely do we find a platform that supports both. In this presentation, we’ll first get an introduction and some clarifications of event-driven versus message-driven systems, event streams, and stream processing. We’ll then take a look at Apache Pulsar which offers a very unique capability in modern, cloud-native applications and architecture, in which its platform supports both Publish-Subscribe and Message Queues, and extends into streams processing as well as performs message mediation & transformation. We will see how it works closely with and relies on Apache Bookkeeper for its durable, scalable, and performant storage of log streams, and leverages on Apache Zookeeper to manage the otherwise very complex ecosystem. We will then compare Apache Pulsar with the popular Apache Kafka platform to understand some of their key differences as to how Pulsar can overcome some of Kafka's limitations. With Pulsar's flexible architecture and cloud-native readiness, we will take a look to see how it can be integrated and work collaboratively with the other frameworks, such as the popular Spring.
When you publish your first HTTP API, you’re more focused on short-term issues than planning for the future. However, chances are you’ll be successful, and you’ll “hit the wall”. How do you evolve your API without breaking the contract with your existing users?
In this talk, I’ll first show you some tips and tricks to achieve that: moving your endpoints, deprecating them, monitoring who’s using them, and letting users know about the new endpoints. The talk is demo-based, and I’ll use the Apache APISIX project for it.
In today’s world, one cluster or one cloud is not enough! The recent outages among top cloud providers made many companies reconsider their single-cloud deployments favoring multi-cloud architectures. But how to connect multiple clouds to achieve the best performance and security?
This talk takes you through practical challenges of building a network backbone for multi-cluster Kubernetes deployments across AWS, GCP, and Azure. You will learn about multi-cloud connectivity options, such as VPN, Network as a Service, or private connectivity, along with cloud-specific limitations, like MTU sizes, BGP quirks, or different HA setups. As CNI plugins are a beating heart of Kubernetes networking, you will see a performance comparison of cloud-native CNI plugins with Calico and Cilium in a multi-cloud setup.
You will walk away with practical knowledge of multi-cloud connectivity options with their strengths and weaknesses.
Blockchain technology is picking up steam and attracting more talent by the day. Have you always wondered how Blockchain works and how can we build on it?
Join me on a live-coding session where we will implement a custody service from scratch! We will start from a Blockchain node and build the capability to send, receive and track a real cryptocurrency.
"Death by a thousand paper cuts" pretty much describes the situation we were in when dealing with issues and pull requests on GitHub for the (very dynamic) Quarkus project.
Until we started automating a lot of things with a GitHub App: that was a game changer.
This session will tell the Quarkus story to GitHub automation and show you how to easily build your own GitHub Apps with Quarkus and the Quarkus GitHub App framework.
Helidon is a brave, small but powerful opensource framework for writing microservices. And if you need get the maximum performance – making your apps reactive is the currently the best way to do it! In this session we will dive deeper and see how to create extremely performant reactive microservices with Helidon “SE” flavour. We will explore its Reactive APIs, asynchronous DB access, and reactive Web-Client. Since Helidon has its own powerful Reactive Engine, we will learn how to get the most requests served in async operations and Messaging. We will also compare the performance with Loom, since Helidon supports it out of the box! Welcome to the Danger Zone!
Developers depend upon an ecosystem of open-source technologies that fuel innovation and decrease time to market. A typical business application is composed of >80% open source code, so what happens when the open source software supply chain gets hacked and thousands of enterprises are left exposed to potentially devastating security exploits. The SolarWinds hack is just the tip of the iceberg on a much larger security concern that spans the industry affecting all programming languages, platforms, and cloud services. In this keynote we will expose security holes and exploits in the open source ecosystem as well as propose a system for securing the software supply chain at a fundamental level.
As we move from monoliths to microservices, the number of things that can go wrong increases. Attempting to perform work
that spans multiple services or data stores requires a lot of state management and reliability code that's difficult to
get right and maintain. Fortunately, we don't have to write it! We can use Temporal, which automatically manages our
application's state in a reliable, fault-tolerant, and scalable way. When we work in this higher level of abstraction,
we spend our time writing business logic instead of state management and reliability code.
In this talk, we will:
- See what this transition looks like, from manual coding to Temporal.
- Learn how Temporal works.
- Build an application with Temporal.
The release of the JDK 17 brings interesting features in the Java language: sealed types and pattern matching for switch. Along with the introduction of records, the implementation of pattern matching in the Java language begins to take shape. This presentation shows you how records, sealed types and pattern matching can change the way we write Java code, on real patterns. It also shows you what we can expect to see on this topic in the future. It is mostly a live coding presentation, with some slides when the code shown cannot be executed.
Jakarta EE 9 lowered the barriers of entry and established a foundation for future innovation paving the way for Jakarta EE 10.
With Jakarta EE 10, we are introducing a new profile - the Jakarta EE Core Profile.
This profile will enable certification of smaller runtimes suitable for microservices as Jakarta EE compatible.
The Jakarta EE Core Profile also aims to be an even better fit for compiling to native images.
But it does not stop there. Both Jakarta EE Web Profile and Jakarta EE Platform is moving forward as well with updates to almost all the individual specifications.
Join this session for the latest updates on the progress with Jakarta EE 10.
I will go through what Jakarta EE 10 brings to the table, and what to expect when the specifications are moving forward.
The session will also give you a clear understanding of how to migrate from previous versions of Jakarta EE and Java EE.
Spring is all about helping developers get to production quickly and safely. These days, "production" is all but guaranteed to mean Kubernetes, and Spring has you covered. Join me, Spring Developer Advocate Josh Long (@starbuxman), and we'll look at how Spring Boot makes writing blisteringly fast, cloud-native, and scalable services more effortless than ever.
Imagine a world where you can access metrics, events, traces and logs in seconds without changing code. Even more, a world where you can run scripts to debug metrics as code. In this session, you will learn about eBPF, a powerful technology with origins in the Linux kernel that holds the potential to fundamentally change how Networking, Observability and Security are delivered.
In this session, we’ll see eBPF in action applied to the Kafka world: identify Kafka consumers, producers and brokers, see how they interact with each other and how many resources they consume. We'll even show how to measure consumer lag without external components. If you want to know what’s next in Kafka observability, this session is for you.
Mother Nature has had millennia to build up its defences to the many potential hazards and attacks it may face. So, given its wisdom and expertise on this subject, what can we as software developers learn from it and bring back to the evolution of our own application’s security? In this session we’ll explore where software and biology overlap when it comes to security and lessons we can learn from nature to improve our own application security.
Introductory session, that will cover all the main features of Quarkus, especially some of the newer features like continuous testing, dev services and the Dev UI.
Qwik is a new bread of frameworks with a goal of instant-on interactivity for your site even on low-power slow-network devices. Qwik is a resumable framework that starts its execution on the server and seamlessly transitions to executing on the client in a very lazy and incremental way. The seamless transition from server to the client provides an instant on-user experience which leads to lower bounce rates, more conversions, and higher sales.
With Partytown for third-party scripts, and Qwik for your first-party applications your browser main thread has never been so bored. Qwik and Partytown are new bread of open-source web technologies that are designed with startup performance first as the main objective and all other design decisions follow from that goal. When Qwik and Partytown are combined with an edge-delivery network it is possible to get your application fully interactive into users' hands in as little as 50 ms setting a new standard of startup performance.
React ecosystem seems to be constantly changing. Wherever we look, there are new libraries and frameworks. These new tools always lead to learning concepts that are often non-transferable knowledge.
What if I told you that by learning standard web APIs and getting a bunch of transferable knowledge, you can also start using a fantastic new addition to the React ecosystem: Remix!
This talk will explain a set of useful reactive patterns for common use cases in Angular apps. Learning those patterns will make your code declarative, cleaner m, more performant and more maintainable.
Serverless is much more than simple HTTP triggered functions. You can run containers and whole apps serverlessly, group functions behind an API gateway, coordinate services with a central orchestrator or let them communicate indirectly via events. You can schedule services or make them more resilient with task queues. You can even combine serverless orchestration with serverful services. In this talk, we’ll look at the serverless landscape beyond simple functions and explore some patterns that help with serverless applications.
In recent times, leading UI frameworks have been encouraging us to take a step toward functional programming as they introduce capabilities such as Custom Hooks (in React) and Composition API (in Vue). This has allowed us to dramatically simplify our components, separate concerns, and efficiently reuse code. However, the true potential of this approach is often overlooked. As we separate business logic from UI logic, we reveal the opportunity to build resilient framework-agnostic frontends that speaks the language of our business model. As we apply DDD principles on such frontends, we unlock powerful possibilities such as adopting micro frontends architectures and building truly autonomous teams that revolve around business aspects rather than on technical expertise.
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.
GraphQL and microservices architectures are perfectly compatible. You can use GraphQL as a data layer for these microservices and combine data from all these services into one universal API. This way, you can break the core of your services into different microservices while still providing one endpoint that your clients can interact with. Before diving into GraphQL, let's explore what microservices are and why it can be helpful to add GraphQL.
Do I need an extension? And how do I write it?
Extensions are a great way of enabling your favourite library to fully take advantage of Quarkus’s capabilities. They can also be used to improve your team’s everyday workflow.
In this talk Georgios and Holly will talk through how extensions can be useful, before live-coding a simple extension. (What it does is a surprise!)
“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
Go through a basic example in Quarkus for both client and server
We will look at the following GraphQL concepts:
Reactive and Non-blocking
Type safe and dynamic clients