Ever wondered what makes a cloud-native application “cloud-native”? Ever wondered what the unique challenges are and how best to address them on fully-open Java technologies? In this workshop, you’ll learn what it means to be cloud-native and how that impacts application development. You’ll learn about Eclipse MicroProfile, an industry collaboration defining technologies for the development and management of cloud-native microservices. With a full set of MicroProfile workshop modules available to you, you’ll be able to start with the basics of REST services and progress to more advanced topics, or you can jump right in and develop secure, fault tolerant, configurable and monitorable microservices. Once you’ve developed your microservice, you’ll learn how to package it in a Docker container and deploy it to a Kubernetes cluster. Finally, you’ll learn the role of a service mesh and use Istio to manage your microservice interactions.
This workshop is for anyone who wants to look beyond the hype and get some hands-on experience developing with blockchain technology. You’ll learn how to use and integrate Java applications with the dominant public blockchain Ethereum. We’ll also touch on the private blockchain technology.
Cloud-native computing is all about smart, continuous delivery of value-driven information services. In this workshop, we’ll learn to use Istio service mesh for smart deployment of microservice systems onto a Kubernetes cluster.
This Best of Java Hands On Workshop introduces various improvements included in Java 9 up to the brand new Java 13. We will have a look at language and syntax improvements as well as new features in streams, optionals, concurrency and HTTP/2, and many more. Your knowledge will be established by a lot of hands on exercises. One key feature in Java 9 is modularization. After an introduction, modularization will be treated in more depth. Starting with simple examples, their complexity grows concerning management of dependencies and realization of service. Additionally, migration is addressed. This is especially important because as of Java 11 some modules like those for JavaFX and XML processing have been taken out of the JDK deployment. The participants will receive a thorough overview of important features in modern Java. This should be helpful for software engineers and for architects to decide if Java 11, 12 or 13 is valuable for their products and to ease migration.
Trust is the metric that best reflects the quality of our relationships and of our social connections. "The more interconnected a system is, the more robust and resilient it will be", finds philosopher Alicia Juarrero. Trust is a metric for social resilience. Political Scientist Francis Fukuyama finds trust to be the pivotal attribute of a successful culture. Trust culture enables societies to leap forward, while distrust results in decline.
We reliably find the absence of trust is the cause for organisations failing to adopt better practices.
We’re predisposed to seek connection; rejection hurts. We get meaning and validation where connection allows us to be authentic and vulnerable. Yet we exist in environments that routinely inform us that what we do and who we are is not "good enough". We are shamed into conformity (often masqueraded as improvement) and blamed for failures.
"The secret killer of innovation is shame. You can’t measure it, but it is there. Every time someone holds back on a new idea, fails to give their manager much needed feedback, and is afraid to speak up in front of a client, you can be sure shame played a part. Shame becomes fear. Fear leads to risk aversion. Risk aversion kills innovation", explains Peter Shearan from his experience working with companies like Apple and IBM.
"Management, in most of its incarnations, is an institutionalized form of distrust" say Robert Solomon and Fernando Flores.
This talk presents the answers I have found: about how we can remain authentic in a blame culture; how we can build authentic trust and enable safe-to-fail environments to strengthen our connections, as well as my experience in applying these practices.
Security is now everyone’s problem, not just something that people who work for banks or Facebook need to worry about. This talk explains how to integrate security into the day-to-day work of a busy software delivery team, the practices that are important to understand, the (limited) role of tools, and how to ensure that every build is as secure as possible.
As our world becomes digital, today's back-office system is tomorrow's public API, open to anyone on the Internet with a hacking tool. So, the days of hoping that security is someone else’s problem are over. Over many years, the security community has developed proven practices to build secure systems and today we have many tools to help create secure software.
However, this knowledge is rarely presented accessibly for mainstream software developers, so the problem for most development teams is where to start and what really matters. This talk will recap security fundamentals, explain the tools and practices that help teams to increase the security of their software and how development teams can integrate these into their normal work. Our technical examples will be Java centric, but the approach is equally applicable to other technology stacks.
In this session, we’ll take a tour of the new features that will help developers as well as things that improve Java deployments. We’ll also discuss issues that will affect migration of applications from earlier versions and choices for which version to choose for deployment.
New Java releases are coming faster than ever, now that we are well into the new six-month release cadence. The number of new features and APIs in each version is less than we’re used to, but the overall rate of change is actually faster than before.
Oracle has changed the license for their JDK, and how updates are made available is also different to what we’re used to. We’ll finish with a quick discussion of the best approaches to take to adapt to this and the choices available.
Are you tired of slow, inaccurate, and painful static and dynamic scanners? Of security vendors putting DevOps lipstick on their legacy tools? In this talk, we will create a continuous, effective, and scalable DevSecOps pipeline using free security tools that leverage the power of instrumentation – like AppD for security. We'll show you how to get started with IAST (Interactive Application Security Testing) to instantly and accurately pinpoint vulnerabilities in your applications and APIs while you code and test. We’ll also set up OSS (Open Source Security) to analyze your libraries for vulnerabilities without scanning. Then we’ll show you how to enable RASP (Runtime Application Self-Protection) to gain full application security visibility and protection in production. Finally, we'll show you how to integrate all this telemetry into tools your teams already use (like Eclipse, IDEA, Slack, GitHub, JIRA, Jenkins, Splunk) using powerful plugins and comprehensive APIs.
Knative is an open-source serverless platform extending Kubernetes to help developers build, deploy, and manage modern serverless workloads. Whether you write functions or applications Knative solves many of the common developer burdens like scaling, resource and route management, or logging and tracing without the need to worry about the underlying infrastructure. Knative also comes with a vibrant ecosystem of multi-cloud event sources which are easy to wire up in your application and trigger your code. And because Kantive is open, you can run it on any Cloud or in your own datacenter where Kubernetes is offered. This session will provide overview of Knative project and introduce many of the common developer and operational patterns used to run real-world solutions.
In this session you will:
Learn what Knative is and what are its benefits
Overview major Knative components and their role
Use demos to illustrate common way to interact with Knative
Have you heard about the latest garbage collectors (GCs) in the OpenJDK HotSpot VM? Are you interested in learning more about their algorithm and design goals? Would you like to hear a basic comparison between them and the current default collector in OpenJDK? If you answered yes to any of the above questions, then this is the session for you!In this session, Monica Beckwith will talk about the Z Garbage Collector (ZGC) and the Shenandoah GC and compare them to the Garbage-First (G1) GC, the current default garbage collector.
This talk tells the story of a recent real life project I did together with four development teams. Learn how we adopted the textbook practices, patterns and principles of Continuous Delivery and applied them to an existing monolithic application. I’ll discuss what worked well and what didn’t, and how we dealt with the messy reality of failing pipelines, flaky tests and brittle infrastructure. Find out how we transitioned from mostly manual, bi-weekly, error-prone releases to 30 automated deployments per day, while significantly reducing overhead and increasing quality.
When running code in a serverless environment two factors become more important than they might have been when running elsewhere. First and foremost as quick start-up time is vital for a good user-experience, because the platform can, at any time, start a new instance of your code to serve a higher request rate. Secondly, as you are typically paying per GB-second of RAM consumed, memory efficiency will save you money directly.
In this talk we will first explore the behaviour of the OpenJDK JVM in a serverless environment – you will learn how to improve memory efficiency and start-up time of the JVM for this environment. We will then see how, using the Fn Project and Oracle Functions, we can easily start using a runtime generated by GraalVM instead of an OpenJDK-based one. We will finish by examining the impact of this change and discussing ideas for further work to improve the user-experience and cost-base of your serverless apps.
Today, programmers do not develop applications from scratch, but rather spend their time fixing, extending, modifying and enhancing existing applications. The biggest problem in their daily work is that maintenance mutates over time from structured programming to defensive programming: The code becomes too complex to be maintained. We insert code we know is stupid from an architectural point of view, but it is the only solution that will hopefully work. Maintenance becomes more and more difficult and expensive. Our software accumulates technical debts.In this talk, you will see how you should improve your architecture and source code to prevent technical debt from growing unrestricted. With the proper knowledge of well-structured architecture, refactorings for tangled code can quickly be found. Complex code can be eliminated, and maintenance costs will be reduced.
Working in a fast-growing company that doubles in size every year while maintaining the quality of products and engineers is a very challenging task.
In this talk, Aviran will describe how Wix.com's corporate structure evolved from functional teams to gangs, cross-functional teams responsible for end-to-end delivery; guilds, professional groups responsible for methodology, best practices, and training; and mini-companies that serve as internal startups to support rapid growth while maintaining velocity. He will also discuss how Wix.com poured its culture into a game-like “guild day” that helps maintain alignment and the high quality of work and people, share knowledge, recruit and preserve the best developers, and support a quality-based culture of innovation.
In the GraphQL world, schema federation is replacing schema stitching. It is the new way to build APIs that aggregate functionality.
In this talk, you will discover a very powerful and flexible way of building federated GraphQL schemas using Java and OSGi, the dynamic module system for Java. You will discover how you can leverage platforms such as Jahia jContent, a CMS using OSGi bundles to enrich its features, to quickly deliver GraphQL services that offer functionality ranging from CMS to customer personalization and segmentation and integrate them with single-page applications.
In today’s Software Development world the number one demand from employers is to deliver features as soon as possible. Everything else is secondary. That means, engineers are doing only one thing: writing new code, debugging, and writing new code again. And most of the time this code is running in one of the very convenient clouds. Rarely anyone ever stops and thinks about performance as a whole. If performance is an issue, the to-go solution is to throw more money at it. Which usually means buying more computing power in the cloud. But is this really the best way of solving that issue? We should make ourselves aware how wasteful our industry is sometimes and think about ways to avoid that.
Creating cloud-native microservices is common – but which programming model to choose from? At the moment, MicroProfile and Spring are two popular programming models for developing microservices. What are the differences or commonalities between them? This session focuses on comparing the two programming models side by side. If you are a Spring developer, after this session, you should be able to grasp MicroProfile very quickly and vice versa. The session also contains a quick demo of developing a Spring microservice and a MicroProfile microservice and then deploy them onto Open Liberty.
Local variable type inference was introduced as a new Java language feature in Java SE 10. Gone are the days of explicitly having to define the type of a variable; let the compiler do it for you with the magic of var! At first sight, this looks like a small change that will eliminate unnecessary boiler-plate code and reduce how much typing (on the keyboard) is required to maintain strong typing (of the language). However, as with many features, there are some unexpected nuances as well as both good and bad use cases.
In this session, we’ll explain the fundamentals of local variable type inference. We’ll then take a series of examples of the use of var and discuss the technical merits of each case.
Twitter is a massively distributed system with thousands of machines running thousands of JVMs. In any similar big system a small change in performance and CPU utilization is multiplied thousandfold and results in big savings. Electricity costs, cooling costs, and possibly reduction of server farm size. One way to improve Java performance and reduce CPU utilization is to simply generate better machine code. Simply is obviously not trivial but doable. Twitter is going down that road and experimenting with Graal to generate better code and reduce cost.
By using Graal, Twitter is saving a lot of money in computation cost. This talk shows the advantages of running Graal in production.
Data scientists know the "magic" of making accurate predictions over time.
However, magic is just sufficiently advanced technology, and most of a data scientist's magic is a good process, good data awareness, and the ability to know whether to make something new or use something that's already out there. In short - it's not all that different from software development, or any other technical field.
Let's go behind the curtains and see the process and the fundamentals employed in making any prediction. Get comfortable with the basics of data science, and learn enough to start adding magic to your work.
As our systems are growing more complex, we've come up with a standard set of ideas to help manage the dependencies between components. Ideas like timeouts, concurrency bounds, and circuit breakers let us control these interactions.
However, these ideas are complex too. Each of them has a variety of knobs to tune, and they're rarely exercised in steady-state. So there's a lot of opportunity for them to behave poorly when called upon, and especially when a few of them kick in at once.
My talk will show how to use chaos engineering to increase confidence in your usage and tuning of timeouts, concurrency bounds, and circuit breakers. You can use these ideas to understand your system better and hopefully make future incidents more manageable.
This example driven talk will guide you through concrete approaches to using continuous profilers in a production environment. Remember the old days, when your software stack was simple to understand and requirements were less demanding? With modern systems, distributed microservices talk to each other all the time over the network. Cloud deployments mean a huge variance in the type of hardware that you deploy to. Rapid iteration and deployment cycles result in rapidly changing workloads that invalidate performance tests before they’re written. Globalised, 24/7 uptimes mean that functional or performance outages aren’t acceptable at any point in time.
These changes have helped businesses get their product out to market much more rapidly, but they often make it harder for developers to find and fix performance problems or to improve the efficiency of their systems. From attending this talk you’ll understand:
Common profiling visualisations and reports
How to use profilers to solve performance problems
The benefits of continuous, exploratory profiling
How to improve scalability, have happier customers and reduce infrastructure costs
Microservices are built using great technologies, programming languages and tools. That's good and right. But unfortunately, it is often lost from sight that the decisive factor is not the technology, but the domain. If we don't cut our microservices according to the domain, then the Big Ball of Mud is simply created at the next higher level. In order to prevent this, I will show you in this lecture which concepts DDD has in store for us, so that our microservices form meaningful self-contained units.
Dr. Carola Lilienthal is managing director at WPS - Workplace Solutions GmbH and has been developing software architectures according to the principles of Domain Driven Design with her teams for more than 10 years. She is author of the book "Sustainable Software Architecture" and in 2017 she translated the book "Domain-Driven Design Distilled" by Vaughn Vernon into German.
Be prepared to challenge your preexisting perspectives of technical leadership as we explore non-traditional approaches and techniques in these immersive, hands-on workshops and presentations.
You will be required to step outside your comfort zone as you share personal experiences and discuss challenging topics such as: giving feedback, working with different communication styles, facilitating effective (non-awkward) 1:1s, practicing authenticity, empowering developers to reach their full potential, and establishing powerful and bullet-proof morning routines to maximize your busy schedules.
In English, Agile means "ability to move quickly and easily", but also "thinking quickly and in an intelligent way". It does not say anything about software, so why couldn't we apply the same concepts everywhere in our life and work? Could a doctor, a lawyer or a chef be Agile? Truth is: we can all be Agile, and it has nothing to do with software! If you start being Agile in most areas of your life, can we assume being Agile while developing software should be easier, more efficient, less stressful and yield better results? In fact, one can use Agile in every part of their life and during this talk I plan to show you how easy it is and how impactful it can be - both for yourself and for the people around you.
GraalVM is a high-performance virtual machine, bringing new performance optimizations for individual languages and seamless interoperability for polyglot applications. Recently GraalVM team released 19.0 — first production release, and we’ll discuss the most recent project updates, and how they can help you make applications development more powerful and productive. You will learn what you can do with GraalVM, in particular: use it as a JVM JIT compiler, run polyglot programs, compile them ahead of time for faster startup and lower footprint, and more. You’ll also discover the best cases for using GraalVM in Java development, where to start, and how to configure it for your project.
Schedulers such as Nomad are most commonly associated with running stateless services. For the Platform team at Samsung Research (Joyent), however, Nomad provides much more than just this. With a Nomad binary installed on servers, the team is able to bootstrap their entire data centre platform in minutes using Nomad to control DB clusters, schema upgrades, package installation and maintenance tasks. This session will dive into the system architecture, discussing the rationale for decisions and tradeoffs made in using Nomad to control more than just the stateless API services the team run.
With less than 3% of young female students identifying a career in technology as their first choice, how are we ever going to achieve a diverse workforce and bridge the gender gap that persists in technology careers? But, don’t panic, this can all still change! Learn how even small events can have a lasting impact in encouraging more females into STEM and technology careers and explore how you can get involved to actively make a difference to the diversity of the tech industry.
In 2019 the bombshell dropped. Java 8 (Long Term Support - LTS) and Java 11 (LTS) are no longer to be distributed by Oracle in the same cost-free and free (as in use) way that the industry is used to! There are still cost-free and free (as in use) ways you can get OpenJDK/Java from Oracle and also production-ready OpenJDK builds by other providers such as IBM, Red Hat, Amazon, and AdoptOpenJDK. Come to this talk to ask the gnarly questions about costs, freedom of use, who governs Java/OpenJDK and what providers you can bet your Java infrastructure on for the next 5, 10, 15 years!
When defining our APIs, we typically look at things from the inside, understanding how our solution works, and then often think more about the functional consideration – what our payload looks like etc. However, good APIs, regardless of whether they’re internal or public facing, are far more than just a payload description and described from the provider’s perspective.
For a good API, we need to consider many more factors: how we communicate, and even what an API is. In this session we will look at what makes up a good API; from OWASP Top 10 implications to ISO and data definitions, why these points are important, and their implications. We’ll explore techniques to overcome the challenges seen in producing good APIs.
Whilst we all think we know how to define APIs, you’ll be surprised about the things that get overlooked or opportunities to do better.
The way in which communication is handled within a cloud native application has changed over the past few years. Kubernetes has become the de facto platform infrastructure, and inter-service communication is now handled via a service mesh. This session will explore how to integrate the open source Ambassador Kubernetes API gateway and the Consul Connect service mesh into your Java apps.
Learn about Kubernetes ingress and inter-service communication
Understand the tradeoffs of using different technologies to implement cloud native communication
Explore how these technologies integrate well – or not – with new and existing Java applications
Hear about lessons learned in production, at 3 a.m., with lots of coffee
Microservices development environment have become more and more popular in cloud-based companies to support better CI/CD methodologies. In this talk, I’ll show a case study illustrating the best practices for managing CI/CD for over 200 microservices on Docker/Kubernetes and Puppet production environments. I’ll also go over how developers can control all of these microservices using various tools, internal developments, and technologies.
Once, long ago, we looked upon serialisation as an important part of Java. As the years passed, we began to recognise the flaws in its design and sighed. Today we realise that the story of serialisation has become a dark and twisted tale.
In this session you'll see why we still need serialisation, how the inbuilt design is fatally flawed and how it is being exploited and used against us. Learn how to work against the dark arts railed against us and understand how even the alternative forms of Java serialisation can still be open to attack.
Does this tale have a happy ending? Can goodness prevail and can you make your application safe from Java serialisation weaknesses? Only you can decide.
Are you looking for the best environment to deploy your new application? Or maybe, you are considering to migrate your existing Java application to the Cloud. On Google Cloud you can find different services to create your infrastructure and it can be difficult to decide which one to use. During this talk I will review with examples the options that we have when we consider Google Cloud and I will provide information to help you to decide the service that could be more useful for your use case.
DevOps and Agile practices aim to create a continuous flow of value. This cultural shift combined with the growing complexity in applications increases the potential for errors in production. Embedding monitoring deeply into your DevOps toolchain is vital to managing this risk. Monitoring helps you improve quality and put customer experience at the heart of your decision making and resource prioritisation. Based on Plumbr team’s own experience and interviews with dozens of companies, this talk will provide best practice advice on how to implement a monitoring solution that adds the maximum value for your DevOps team.
In this session, we will take a look at various ways of encoding numbers, floating points, and byte streams as text in base 2, 10, 16, 58 (bitcoin), 64, and using words to encode using base 4096. Text formats can be used to avoid binary characters, make human-readable, easier to read and easier to remember. In one example, we'll look at how to encode latitude and longitude as four words to make it easier to read and remember. The exact encoding can be changed to suit your use case.
Learn what problems blockchain can solve by integrating it into your technical stack and how easy it can be to build your application in Java using all your familiar tools and frameworks. The world’s first public JVM-compliant blockchain platform allows you to build production grade applications on the blockchain using Java.
You probably work on a distributed system. Even if you don't yet face a serverless microservice architecture using fancy NoSQL databases, you might simply call some remote services via REST or SOAP. This leaves you in charge of dealing with consistency yourself. ACID transactions are only available locally within components and protocols like two-phase commit don’t scale. Many projects either risk adventurous inconsistencies or write a lot of code for consistency management in the application layer. In this talk I discuss these problems and go over possible solutions, including the Saga-Pattern. I will discuss recipes and frameworks that ease the management of the right level of consistency. This allows you write business logic code. Expect fun little live hacking sessions with open source components, but also real-life stories.
Java 9 introduced modules as first-class citizens that represent a higher level of aggregation above packages. They allow you to implement more robust software systems by providing stability, cohesiveness, encapsulation, and isolation.
Modularizing a 'hello world' application is pretty straightforward, but it provides only limited benefits. That's because the primary strength of modularization lies in its ability to impose a clear structure on large codebases. However, modularizing a large codebase is not a trivial task.
In this talk, we will discuss the difficulties encountered when implementing a real-life modular application and how to overcome them. We will also focus on the usage of build tools such as Gradle and Maven to compile, test, build and run modular applications. In addition, we will explore a series of plugins that automate tasks such as:
Creating modular jars that target a Java release before 9
Using JavaFX in Java 11+ applications
Creating custom runtime images
Packaging native installers using the 'jpackage' tool introduced in Java 13
In this session we will look at troubleshooting production problems which have caused outages in major enterprises. We will analyze the actual thread dumps, heap dumps, GC logs and related artifacts that were captured at the time of the problem. You will learn how to apply the right analysis patterns, tools and best practices to troubleshoot these complex problems. After this session, troubleshooting CPU spikes, OutOfMemoryErrors, response time degradations, network connectivity issues and application unresponsiveness will not stump you anymore.
Do you love Kotlin? Do you think you know all about Kotlin? This talk will challenge you! If you are a Kotlin beginner, it will introduce you to some secrets of the language. Kotlin is a language which is very easy to learn for Java developers. Its gentle learning curve should not prevent us from exploring the more advanced features and aspects.
Having already worked with Kotlin in many projects, I have discovered a few useful tricks and not-so-widely-known features that can be beneficial for programmers of any level: From a series of posts on my blog, I will show things that people don't know you can do with Kotlin.
JVMs and containers are like fries and mayonnaise – better together!
Container technologies such as Docker have rapidly become the de-facto way to deploy applications. In addition, emerging platforms, projects and tools (Knative, OpenFaaS, Fn Project, JIB, and more) either simplify or fully abstract building container images, which in turn makes leveraging containers with Java natural.
During this technical session, we will discuss best practices of using the JVM with containers:
Techniques and tools to optimize containers size (e.g. jlink, Project Portola)
Approaches to improve applications startup time (e.g. CDS)
Benefits of using Graal SubstrateVM for AOT (Ahead-of-Time) compilation
The recent OpenJDK enhancements that improve the interactions between the JVM and Docker, etc.
Attend this session to understand how you can better leverage one of today's most used programming platform, i.e. the JVM, with the most common tool to deploy code, i.e. containers.
In this talk, Peter Lawrey looks at the open source platform Chronicle Decentred and how it can be used to implement microservices in a Byzantine Fault Tolerant cluster of nodes. One of the key advantages of a public blockchain is that organisations can work together without needing to trust each other, rather they trust the protocol, something which cannot be achieved with a traditional database.
Not all containers are trustworthy – and even those you build yourself can be hacked. Malicious software might be included in the images, or downloaded into the container at runtime. While generic containers should keep the bad guys contained (hence, the name) it is possible to further improve security by limiting which system calls a container may execute. In this talk we’ll explain what system calls are, exactly how to filter them with Kubernetes and Docker, and how doing so improves security.
As a tester, I don’t break your code, I break your *illusions* about the code. And illusions come in many forms. Illusions may be about the code doing what it’s supposed to; about the product doing what it would need to; about your process is able to deliver with change in mind; people having the skills to deliver well and about the business growing with uninformed risks on the product and the business model around it.
This talk goes through examples of illusions that need to be broken and skills that you need to build to break them. Testing is not just the technical checks but more relevantly it’s about discovering information about threats to value you’re trying to create.
We will address:
Types of illusions testers break with examples from the speaker’s 20 years in testing
Skills teams need to build to learn to evaluate the product by learning about it through exploration and experimentation
Creating a culture of feedback and experiments with diversity of personalities and skills in the teams
In a cloud native world enamored with Microservices and Serverless, meet Quarkus—Java’s brilliant response to technologies like Node.js, Python and Go that had until recently proven quicker, smaller and arguably more nimble. But we know seeing is believing—we’ll show you Quarkus in action. Get ready to experience “Supersonic, Subatomic Java”— and make open source frameworks like Hibernate and Apache Camel faster, smaller and more dynamically scalable than ever before!
In this talk, you will hear how containers are also changing the way that developers code, test and deliver. Learn about techniques that are being designed that will help reduce the knowledge burden on developers and are providing development environments more suitable to the new world of Cloud Native.
The rise of containerized applications, the need to deliver on the promise of polyglot microservice architectures and the growth of Kubernetes as the orchestration system of choice are all contributing to a development model that is quite different from the past and which is greatly increasing the amount of expertise and knowledge a developer needs on a daily basis.
This session will help you get a clearer view of the choices coming your way — from new platforms like Knative or Jenkins X through emerging event-based application architectures to new open source development tools designed to help manage the new complexities of being a developer. We'll explore the principles behind these tools, why they are important and educate you on what you should be learning.
The shift from monolithic applications to microservices led to many new challenges we haven't had before. Especially analyzing problems and tracking down erroneous components of a distributed system has become much more difficult as slicing and decoupling applications advances. We now have to answer questions like: How do we find out which services were involved when processing a specific request and how long did it take to respond? How do we figure out which service is causing a request to fail and why? These issues are addressed by Distributed Tracing tools like Zipkin, Jaeger, OpenTracing and OpenCensus. But how can we leverage the data we are gathering using such tools to gain new insights into our business processes, instead of just focussing on the technical aspects?
In this talk, we will give an introduction to Distributed Tracing focussing on the OpenTracing ecosystem, how it compares to similar tools and how you can benefit from using such tools. We will also show how you can take Distributed Tracing to the Next Level and turn it into Distributed Business Tracing. We will use practical examples to show how this has changed our organization.
Microservices are at the top of the hype right now and perhaps you’ve already fallen for them and are replacing your good old monolith for new shiny microservices on the back-end.
That’s what Micro Frontend is and that’s what we’ve done at Saagie. In this talk I’d like to give you feedback on the different architectures we’ve tried, their pros and cons and help you find which one would be the best for you, just in case you’d like to opt for the dark and crazy side of front-end.
Apache Kafka has transformed our ability to move and process data. The old accepted approaches of request/response and RDBMS in system design are no longer the de facto options. However, what does this mean for the way we manage and store the state within our systems?
Event logs often have the full state within them, but that doesn’t necessarily mean that reading the event log from the start to build the current state is the best way to store and manage it. When considering event log based systems, it is vital to think carefully not only about functional considerations, but also non-functional considerations.
This talk is about the importance of considering performance, data consistency and latency from the start when architecturally planning event log systems. It will give examples how developers who were new to Kafka tried various different approaches to managing state in such systems. It shows the successes, the failures and the lessons learned and how an approach to managing state in an event log evolved, and where we hope to take it.
Does Kafka’s long living, persistent event log mean that we can now realise a utopia of fully stateless systems? Look before you leap, says Ben Abramson …
Quality is that elusive concept we know when we don’t have. Whether it is problems in how the software works or missing users' needs and requirements, quality is what goes wrong. And we don’t want things to be wrong, quite the opposite!
In this talk, we dive into stories about quality and caring for quality, all the way to production and beyond. We look at modern craftership and how eventually learning is the key: every day we should be improving our (thinking) tools and outperforming our past selves, which is only possible through being deliberate about learning.
After this session you will be able to say Garbage Collection tuning isn’t rocket science, it’s common sense. You will learn Key Performance Indicators (KPIs), useful tools, best practices and algorithms to tune your system's garbage collection. Besides tuning, you will also learn how to use garbage collection metrics to troubleshoot and even forecast memory problems.
Ever wondered what makes a cloud-native application “cloud-native”? Ever wondered what the unique challenges are and how best to address them on fully-open Java technologies? In this workshop, you’ll learn what it means to be cloud-native and how that impacts application development. You’ll learn about Eclipse MicroProfile, an industry collaboration defining technologies for the development and management of cloud-native microservices. With a full set of MicroProfile workshop modules available to you, you’ll be able to start with the basics of REST services and progress to more advanced topics, or you can jump right in and develop secure, fault tolerant, configurable and monitorable microservices.Once you’ve developed your microservice, you’ll learn how to package it in a Docker container and deploy it to a Kubernetes cluster. Finally, you’ll learn the role of a service mesh and use Istio to manage your microservice interactions.
Continuous Integration (CI) and Continuous Delivery (CD) are development practices of applying small code changes frequently. It’s well known that it becomes more and more essential to any agile-based organization.
This workshop will help you to understand the CI/CD concepts, mindset, and how to implement the practices that help to form the DevOps culture to implement CI/CD for software development.
This workshop is for anyone who wants to look beyond the hype and get some hands-on experience developing with blockchain technology. You’ll learn how to use and integrate Java applications with the dominant public blockchain Ethereum. We’ll also touch on the private blockchain technology.