We live in a world of microservices. Yet, what is a microservice? What defines the boundaries of a microservice? How do we define the relationships between microservices? Thankfully domaindriven design gives us the concepts and practices to better design and decompose our services.

In this session we will consider many of the concepts of DDD — How bounded contexts use Ubiquitous language to model the domain, how context maps can be used to establish the interconnections between services as well aggregates and domains events, all of which will service us well as we go about creating our microservices.

In this session we will go further with DDD, considering aspects like aggregates, domain events, factories and repositories, and consider how DDD can be represented in architecture, be that hexagonal, REST or RPC.

If you need a deeper dive into DDD, then this is the session for you.

Docker compose has been a part of the docker ecosystem since the beginning. It allows us to “stitch” together our services so that we can deploy all our services and related infrastructure using the “one” button. Furthermore, we can now use docker-compose to target Kubernetes, exemplifying the role that docker compose has to play in our day to day interaction with Docker.

If you are new to docker-compose then this is the session for you. Lets take a look at the capabilities of docker-compose, see what it takes to use it for local development and testing, and finally see how we can target Kubernetes so we can mimic our production deployment on our laptops.

Some say that data is the new oil, and like oil, data needs to be collected, refined, and distributed to gain value from it. For years we've collected data into tankers called databases, and when we had enough, we shipped batches of it to be refined by some process. Then when that was done, we'd make it available to end-users. However, unlike oil, data tends to lose its value the longer we wait to use it. (Data is the new milk?)

So, what if we could hook up a pipeline* to the source of the oil, er… data, and transform it in near real time, on its way to the end-users? That's precisely what we can do with Apache Kafka and Kafka Streams. In this session, we’ll see how we can use Kafka Streams to enrich, aggregate, summarize, and otherwise transform our data while it is flowing through our systems.

These pipelines are completely harmless to the environment.

Architecture is not a static representation of a system. There are several complexities and risks involved in creating them. One way to mitigate the risk is to evolve the architecture. But, there are risks of evolving as much as there are the risks of not evolving. In this interactive workshop we will explore a set of practices that we can use to mitigate the risks. Then we will dive into discussing some common and popular architectural patterns.

Finally, we will take some example applications and discuss how to evolve architecture to meet the needs of those applications.

Workshop Requirements

Computer with git client installed to access the version control system which will have lab related material.

Architecture is not a static representation of a system. There are several complexities and risks involved in creating them. One way to mitigate the risk is to evolve the architecture. But, there are risks of evolving as much as there are the risks of not evolving. In this interactive workshop we will explore a set of practices that we can use to mitigate the risks. Then we will dive into discussing some common and popular architectural patterns.

Finally, we will take some example applications and discuss how to evolve architecture to meet the needs of those applications.

Workshop Requirements

Computer with git client installed to access the version control system which will have lab related material.

Java 8 has been around for a few years and by now we all have immersed into the Streams API and the lambda expressions. But, what does it mean to program in functional style? How can we leverage the functional APIs to solve problems. How do we think in functional style when we have so much experience with imperative style. And flat…what and do they really mean we should honor immutability?

This presentation will answer those questions using practical examples so you can leverage the power of functional Java in your own applications.

Jamie Zawinski once said “Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.“. Many consider regular expressions to be indecipherable, but the truth is that every programmer should consider regular expressions an integral part of their toolkit. From the command line to your favorite text editor, from parsing user input to scraping HTML pages once you know regular expressions you will find a use for them in almost every programming context.

In this highly interactive workshop we will decipher the cryptic construct that is a Regular Expression. Starting with the basics, we will work our way towards advanced usage, including anchors, modifiers, groups, and look arounds.

This is a HIGHLY interactive workshop — Not only will we have a lot of exercises, we will use a playground that will allow us to experiment to our heart's content! Feel free to come in with issues you may have seen at work!

Agenda:
The basics and how to read regular expressions
Character Classes
Negation
Ranges
Shortcuts
Alternations
Repetitions
Word Boundaries
Capture Groups
Anchors
Modifiers

Let's once and for all make sense of this powerful tool.

I hope to see you all there.

Jamie Zawinski once said “Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.“. Many consider regular expressions to be indecipherable, but the truth is that every programmer should consider regular expressions an integral part of their toolkit. From the command line to your favorite text editor, from parsing user input to scraping HTML pages once you know regular expressions you will find a use for them in almost every programming context.

In this highly interactive workshop we will decipher the cryptic construct that is a Regular Expression. Starting with the basics, we will work our way towards advanced usage, including anchors, modifiers, groups, and look arounds.

This is a HIGHLY interactive workshop — Not only will we have a lot of exercises, we will use a playground that will allow us to experiment to our heart's content! Feel free to come in with issues you may have seen at work!

Agenda:
The basics and how to read regular expressions
Character Classes
Negation
Ranges
Shortcuts
Alternations
Repetitions
Word Boundaries
Capture Groups
Anchors
Modifiers

Let's once and for all make sense of this powerful tool.

I hope to see you all there.

You have been using Git for a while. You know how to stage and commit your work, create and delete branches and collaborate with your team members using remotes. But Git often leaves your confused — ever committed to your work to the wrong branch? Even worse, ever accidentally delete a branch that you needed to keep around? And what is God's good name is “Detached HEAD state”? Why tag commits, when we have branches? Is there a better work-flow than just using merges? What's the difference between a merge and a rebase?

The answer to all of these questions, and more, lies in the constitution of a commit, and the directed acyclic graph (DAG) that Git uses to manage your history. This, right here, is the key to understanding everything in Git.

In this hands-on workshop, we will level up your Git skills. We will foray into the underbelly of Git, and reveal the mystery behind the arcane interface that is the Git CLI.

By the end of this workshop, you will have a keen understanding on how best to use Git, as well as know how to dig yourself any prickly situation you might find yourself in. You will become your team's hero(ine). Most importantly, you will walk away with a keen appreciation of how beautiful and elegant Git really is.

You have been using Git for a while. You know how to stage and commit your work, create and delete branches and collaborate with your team members using remotes. But Git often leaves your confused — ever committed to your work to the wrong branch? Even worse, ever accidentally delete a branch that you needed to keep around? And what is God's good name is “Detached HEAD state”? Why tag commits, when we have branches? Is there a better work-flow than just using merges? What's the difference between a merge and a rebase?

The answer to all of these questions, and more, lies in the constitution of a commit, and the directed acyclic graph (DAG) that Git uses to manage your history. This, right here, is the key to understanding everything in Git.

In this hands-on workshop, we will level up your Git skills. We will foray into the underbelly of Git, and reveal the mystery behind the arcane interface that is the Git CLI.

By the end of this workshop, you will have a keen understanding on how best to use Git, as well as know how to dig yourself any prickly situation you might find yourself in. You will become your team's hero(ine). Most importantly, you will walk away with a keen appreciation of how beautiful and elegant Git really is.

JavaScript now has a yearly release cycle. Every release introduces new features that aim to make us (JavaScript developers) more productive, while making our code succinct, expressive, and (potentially) bug-free.

By the end of this workshop you will be intimately familiar with the newer set of JavaScript features, and ready to dive into your next JavaScript project with confidence.

This workshop allows you to explore many of the new features that we use on a daily basis, including

let and const
Default parameters
The new “fat arrow” function syntax
Template strings
Object and array de-structuring and spread
The newly added Map / Set data-structures
The new class syntax as well as static/private members and methods
Promises and async/await
Modules
Optional catch binding
Nullish coalescing operator / Optional chaining operator

This workshop uses tests to verify and validate all of your changes, so you can be confident in your changes as you go about refactoring your code to use modern JavaScript language features.
Each section of the workshop builds on the previous one, allowing you to continuously refactor code and get tons of practice.

If you want to be fully caught up with all of the changes that have landed in JavaScript between 2015 and 2021, this is the workshop you want to attend!

Workshop Requirements

Please follow the instructions in the README.md file of https://github.com/looselytyped/refactoring-to-modern-javascript

NOTE — If you get an error be sure that your Node version is up-to-date. Older versions of Node did not support ES modules natively, and you might run into issues.

If you cannot upgrade Node, consider using a tool like https://github.com/nvm-sh/nvm/blob/master/README.md (Mac/Linux) or https://github.com/coreybutler/nvm-windows (Windows) so you can run multiple version of Node simultaneously.

JavaScript now has a yearly release cycle. Every release introduces new features that aim to make us (JavaScript developers) more productive, while making our code succinct, expressive, and (potentially) bug-free.

By the end of this workshop you will be intimately familiar with the newer set of JavaScript features, and ready to dive into your next JavaScript project with confidence.

This workshop allows you to explore many of the new features that we use on a daily basis, including

let and const
Default parameters
The new “fat arrow” function syntax
Template strings
Object and array de-structuring and spread
The newly added Map / Set data-structures
The new class syntax as well as static/private members and methods
Promises and async/await
Modules
Optional catch binding
Nullish coalescing operator / Optional chaining operator

This workshop uses tests to verify and validate all of your changes, so you can be confident in your changes as you go about refactoring your code to use modern JavaScript language features.
Each section of the workshop builds on the previous one, allowing you to continuously refactor code and get tons of practice.

If you want to be fully caught up with all of the changes that have landed in JavaScript between 2015 and 2021, this is the workshop you want to attend!

Workshop Requirements

Please follow the instructions in the README.md file of https://github.com/looselytyped/refactoring-to-modern-javascript

NOTE — If you get an error be sure that your Node version is up-to-date. Older versions of Node did not support ES modules natively, and you might run into issues.

If you cannot upgrade Node, consider using a tool like https://github.com/nvm-sh/nvm/blob/master/README.md (Mac/Linux) or https://github.com/coreybutler/nvm-windows (Windows) so you can run multiple version of Node simultaneously.

Embraced containers yet? If so, that only presents the beginning of the journey. Designing your images to be lean, and your containers configurable requires us to leverage Dockerfiles to their maximum potential. At scale, everything matters—build times, testing, multi-stage builds, conventions around tagging and logging. There is a whole ecosystem of tools around how we can best build our images and containers.

In this session we will learn many a trick on how we can leverage Docker's own tooling as well as third-party tools to ensure that our first steps in the container world are the right ones.

A large part of embracing DevOps involves embracing automation. Over the last decade we have seen the emergence of “as Code” — Build-as-Code, Configuration-as-Code and Infrastructure-as-Code. The benefits to utilizing such tools are huge! We can codify the state of the world around our applications, giving us the ability to treat everything that our code needs like we treat the code itself. Version control, release management, tagging, even rolling backs are now possible. Terraform, an open-source tool from HashiCorp allows us to build, control and modify our infrastructure. Terraform exposes a Domain-specific language (DSL) that we can use to express what our infrastructure should look like. Terraform can work with all the major cloud providers, including Amazon AWS, Google GCP and Microsoft Azure. If you are curious about what this tool has to offer, this session is for you. Come on in, and let's learn how to terraform your cloud.

This session will focus on Terraform. We will look in to how this tool works, explore its capabilities, and see how it can play a pivotal role in our Infrastructure-as-Code (IaC) strategy. With lots of code and demos, this session will certainly give you enough fodder for thought, and provide a baseline so you can decide if Terraform is right for you.

Many developers around the world have jumped on the Microservices bandwagon. Several organizations, in the past and also in the present, have built around monolithic and also service oriented architectures. What separate, however, Microservices from those efforts at large? How does a Microservices based architecture influence the design of the software applications, what are the key design principles we should keep in mind, and how to leverage design goals like reuse and extensibility?

In this presentation we will revisit the design goals we often focus on in software development and how those evolve in the context of Microservices.

Continuous refactoring is critical to succeeding in projects and is an important part of sustainable agile development.

In this workshop, we will start by discussing how to approach refactoring, the essential steps we need to take, and look into how to incrementally improve the internal design of code to make it extensible, maintainable, and cost-effective to change. In addition to discussing the concepts, we will take several code examples from real projects, discuss the code smells and explore the refactoring techniques. Along the way, we will also dive into refactoring short code samples and measure the quality of code before and after refactoring.

Workshop Requirements

Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE

Continuous refactoring is critical to succeeding in projects and is an important part of sustainable agile development.

In this workshop, we will start by discussing how to approach refactoring, the essential steps we need to take, and look into how to incrementally improve the internal design of code to make it extensible, maintainable, and cost-effective to change. In addition to discussing the concepts, we will take several code examples from real projects, discuss the code smells and explore the refactoring techniques. Along the way, we will also dive into refactoring short code samples and measure the quality of code before and after refactoring.

Workshop Requirements

Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE

Event-driven architectures look great on paper (or a whiteboard), but it's easy to run into snags when trying to implement them. In this talk, we'll see how tools from the Apache Kafka ecosystem can make this task easier and a lot more fun!

In this session, with Apache Kafka as the backbone, we'll use Micronaut to implement an event-driven architecture that is loosely coupled and easily extensible. Then we'll extend it with a Kafka Streams application without affecting any of the existing applications.

Over the last decade, DevOps has emerged as an influential business philosophy and practice, helping businesses drive high quality software to market faster. DevOps focuses on the elimination of bottlenecks that occur when development and operational resources are too divorced from one another. But what about friction in the development and test process? What about the delayed feedback cycles that come from slow builds and test flakiness? How can we reduce friction in areas that are outside of the focus of DevOps? Raju Gandhi, Developer Advocate at Gradle Enterprise, will talk about how the emerging practice of DPE addresses these questions. The presentation will include examples of DPE practices in action from Java projects using the Maven or Gradle build tool.

Attendees will walk away from this presentation with a better understanding of:

Acceleration technologies for speeding up feedback cycles
How to use data analytics to quickly determine the root cause of problems and prevent problems from happening in the first place
The costs of a low productivity environment with wasted time waiting for builds, tests, and CI/CD pipelines
The importance catching errors earlier, including incorrect signals like flaky tests
How to make the practice of developer productivity engineering a respected discipline

In this example-driven session, we'll review several tips and tricks to make the most out of your Spring development experience. You'll see how to apply the best features of Spring and Spring Boot, including the latest and greatest features of Spring Framework 6.x and Spring Boot 3.x with an eye to what's coming in Spring 7 and Boot 4.

Spring has been the de facto standard framework for Java development for nearly two decades. Over the years, Spring has continued to evolve and adapt to meet the ever-changing requirements of software development. And for nearly half that time, Spring Boot has carried Spring forward, capturing some of the best Spring patterns as auto-configuration.

As with any framework or language that has this much history and power, there are just as many ways to get it right as there are to get it wrong. How do you know that you are applying Spring in the best way in your application?

Workshop Requirements

You'll need…

A Java IDE of your choice. I'll be using IntelliJ, but you are welcome to use Spring Tools, Netbeans, or whatever you prefer for Java development. (Spring Tools–either the Eclipse or VSCode version–or IntelliJ is recommended, though).
Java 17 or higher. I recommend using SDKMan (https://sdkman.io/) for managing multiple versions of Java on your machine. I'll be using Zulu 17.0.6 for most tasks, but may switch to a Liberica NIK version for purposes of native builds.
Docker (optional, but may be necessary for some tasks)

In this example-driven presentation, we'll focus on how to build reactive APIs in Spring. We'll start with Spring WebFlux, a reactive reimagining of the popular Spring MVC framework for HTTP-based APIs. Then we'll have a look at RSocket, an intriguing new communication protocol that is reactive by design.

Traditionally, applications have been built using a blocking, synchronous model. Although comfortable and intuitive for most programmers, this model doesn't scale well. And although there are several new approaches to reactive programming, they don't necessarily fit into the familiar programming model that Spring developers are accustomed to working with.

Spring 5 introduced a set of new reactive features, enabling non-blocking, asynchronous code that scales well using minimal threads. Moreover, it builds on the same concepts and programming models that Spring developers have used for years.

In this example-driven presentation, we'll take a high-level look at how Spring applies reactive programming at all layers of an application. You'll also learn the essentials of working with Project Reactor, the reactive programming library for Java that Spring's reactive support builds upon.

Traditionally, applications have been built using a blocking, synchronous model. Although comfortable and intuitive for most programmers, this model doesn't scale well. And although there are several new approaches to reactive programming, they don't necessarily fit into the familiar programming model that Spring developers are accustomed to working with.

Spring 5 introduced a set of new reactive features, enabling non-blocking, asynchronous code that scales well using minimal threads. Moreover, it builds on the same concepts and programming models that Spring developers have used for years.

In this example-driven presentation, we'll focus on working with reactive data persistence. We'll start by seeing how to create reactive repositories for relational databases with Spring Data R2DBC. Then we'll explore non-relational reactive persistence for MongoDB and Cassandra.

Traditionally, applications have been built using a blocking, synchronous model. Although comfortable and intuitive for most programmers, this model doesn't scale well. And although there are several new approaches to reactive programming, they don't necessarily fit into the familiar programming model that Spring developers are accustomed to working with.

Spring 5 introduced a set of new reactive features, enabling non-blocking, asynchronous code that scales well using minimal threads. Moreover, it builds on the same concepts and programming models that Spring developers have used for years.

Contrary to popular belief, software engineering culture is not about the free food, open office spaces, and ping pong tables.

You can sense a great team culture when you observe it, and unfortunately you've probably experienced (or are currently experiencing) elements of a bad team culture. Not to worry - it's never too late to grab the reins and make small changes to steer your team in the right direction!

In this talk, Kate will highlight 8 tactical tips that attendees can implement on their teams immediately to help shape their team's culture!

Delivering feedback is arguably the hardest part of being a leader. Eventually, the time will come when someone on your team isn’t meeting expectations, and you will be faced with a choice. You can choose to ignore the situation, hope it improves organically, and accept the toll it takes on the broader team, or you can choose to have the tough conversation.

In this interactive session, you will learn more about your communication style, a simple framework to provide actionable feedback, common red flags to watch out for, and advice on how to quickly course correct on a dev team. You’ll leave with a template for giving feedback that you can tie directly to a situation you’re currently facing as well as plenty of examples that you can leverage in the future.

Time management + prioritization - everyone needs it! We all seem to face a never-ending list of demands coupled with a finite amount of time to get it all done.

You will leave this 60 minute session armed with new tips and tools to effectively balance your time between meetings, writing code, putting out fires, and clarifying your role to ensure you are spending time on the things that actually matter!

Our software engineering teams are facing new challenges every day that come with the rapidly changing industry and recent events.

People don't seem to be motivated by the same things that they previously found compelling. Organizations are giving up glamorous office spaces and pivoting to remote teams. These changes require us to quickly pivot as leaders to learn new skills, frameworks, and techniques to continue supporting our teams while maintaining our own sanity.

In this workshop, you will learn and practice key skills to help your team propel through today's modern challenges and setbacks. The topics will be relevant to all Software Engineering leaders who wish to find ways to motivate and inspire their teams - regardless of their organization's existing circumstances.

Specific topics will include:

Tips and tricks for leading remote teams - striking the right balance between productivity and flexibility
Understanding unique motivational styles - catering your leadership style to maximize employee engagement
Advanced communication techniques - communicating authentically, consistently, and purposefully to provide reassurance and clarity to your team

Workshop Requirements

Activities will require a handout - please download (and print if preferred) the course handout located in the Slides folder.

Our software engineering teams are facing new challenges every day that come with the rapidly changing industry and recent events.

People don't seem to be motivated by the same things that they previously found compelling. Organizations are giving up glamorous office spaces and pivoting to remote teams. These changes require us to quickly pivot as leaders to learn new skills, frameworks, and techniques to continue supporting our teams while maintaining our own sanity.

In this workshop, you will learn and practice key skills to help your team propel through today's modern challenges and setbacks. The topics will be relevant to all Software Engineering leaders who wish to find ways to motivate and inspire their teams - regardless of their organization's existing circumstances.

Specific topics will include:

Tips and tricks for leading remote teams - striking the right balance between productivity and flexibility
Understanding unique motivational styles - catering your leadership style to maximize employee engagement
Advanced communication techniques - communicating authentically, consistently, and purposefully to provide reassurance and clarity to your team

Workshop Requirements

Activities will require a handout - please download (and print if preferred) the course handout located in the Slides folder.

Kubernetes has become the de-facto orchestrator for containers and now is the best way to start engaging with portable distributed computing. This workshop is for software application developers who want to understand what Kubernetes is all about and how it works. It can be a seemingly complex ecosystem full of terms, architectures, and misinformation. We will break it down so you have a solid understanding of how it works so you can start writing applications that run on this distributed platform.

We will cover many topics such as:

Rise of Kubernetes and containers
Terms and architecture
What does it give me?
App Patterns on Kubernetes
Building, deploying, serving, and observing apps on Kubernetes.
Hands on labs

Kubernetes has become the de-facto orchestrator for containers and now is the best way to start engaging with portable distributed computing. This workshop is for software application developers who want to understand what Kubernetes is all about and how it works. It can be a seemingly complex ecosystem full of terms, architectures, and misinformation. We will break it down so you have a solid understanding of how it works so you can start writing applications that run on this distributed platform.

We will cover many topics such as:

Rise of Kubernetes and containers
Terms and architecture
What does it give me?
App Patterns on Kubernetes
Building, deploying, serving, and observing apps on Kubernetes.
Hands on labs

Kubernetes is highly configurable and extensible. As a software developer, once you understand how something works the next thing you naturally ask is how to extend it to meet your needs. Kubernetes is declarative by its nature which allows you to configure the state of a cluster to meet your needs. However, with all of the Kubernetes resources, it can't do everything. Fortunately, Kubernetes has a build-in architectural feature of extensibility.

In this workshop, we will build on your existing knowledge of containers and Kubernetes and add techniques for extending Kubernetes to help to meet your real world needs.

We will cover many topics extensibility, such as:

Kubernetes API
Custom Resource Definitions
Controllers
Security and Roles
Kubectl plugins
Operator Pattern
Public Operators
Choices for developing your own Operator
Hands on labs

Kubernetes is highly configurable and extensible. As a software developer, once you understand how something works the next thing you naturally ask is how to extend it to meet your needs. Kubernetes is declarative by its nature which allows you to configure the state of a cluster to meet your needs. However, with all of the Kubernetes resources, it can't do everything. Fortunately, Kubernetes has a build-in architectural feature of extensibility.

In this workshop, we will build on your existing knowledge of containers and Kubernetes and add techniques for extending Kubernetes to help to meet your real world needs.

We will cover many topics extensibility, such as:

Kubernetes API
Custom Resource Definitions
Controllers
Security and Roles
Kubectl plugins
Operator Pattern
Public Operators
Choices for developing your own Operator
Hands on labs

Java developers and specifically Spring enthusiasts, fear not, Spring-based containers on Kubernetes continue to improve!

Write once, run anywhere, the promise of the JVM (WORA). Package once, run anywhere, the promise of containers (PORA). Given these two postulates, isn't WORA and PORA the same goal with different technologies? Yes, it’s completely redundant, and wasteful on expensive cloud servers. GraalVM has given us a way to reduce this waste with significant CPU and memory advantages. This solution has arrived with Spring Native.

We’ll walk through a hands-on session to see how much Spring Native can save you.

Don't fear entropy, embrace it.

When you move toward distributed computing the likelihood of failure proportionally increases. It's not your fault, it's simply physics. Once you start spreading your data and applications across more devices, then access to resources such as CPU, memory, and I/O have a higher rate of failure.

Embrace entropy with chaos experiments and increase your cloud native capability model. We’ll investigate some of the leading chaos frameworks for Kubernetes and dive into hands-on experiments targeted within blast radiuses.

Have you looked at the methods of CompletableFuture and wondered how to actually use them? Do the function names appears strange or at least different from what we're used to. Let's take another look so those names become easier to remember and also to make use of.

In this presentation we will take a practical look at CompletableFuture and how to make good use of it, and how to deal with exceptions.

In recent years the development of the Java language has accelerated significantly. Some of the more recent features are quite exciting and can lead to better modeling, fewer errors, less verbosity, and better developer productivity. In this presentation we will take a close look at these features and their significance. We will use concrete examples as use cases to explore the modern features. In addition to looking at these features we will also take a look under the hood at how these are implemented. This will help us to gain a better understanding of the builtin efficiencies these features come with.

Get ready to take part in some live coding as we dive into these amazing features.

Functional and reactive programming is gaining popularity and use. One hurdle developers face using these approaches is in exception handling. Dealing with exceptions in these styles is confusing in the beginning and is often messy and error prone. In this presentation we will step back and take a closer look at exception handling, about the functional and reactive programming and discuss the dos and don'ts for exception handling. We will learn using concrete examples and live coding to illustrate the problem and the possible solutions.

We will explore options available in different languages and libraries and learn from them

There are some amazing features that are being introduced in Java in the coming years. Some of these features are just around the corner. However, these features, in various forms, have been in other languages for a while.

In this presentation we will take a look at some features in Kotlin, Scala, and JavaScript that are soon to be features of Java, understand their power and benefits and how we can make use of them. We will relate these features to how they are manifesting in Java.

The power of Java's functional programming goes far beyond lambdas and the filter, map of the Stream API. In this presentation we will look at various data transformations and see how the functional APIs in the JDK can provide concise solutions for these.

We will start with the Stream's API and quickly dive into some newer functions and also the utilities of the Collectors. Along the way you will get a deeper understanding of some of the excellent functions that are hidden in plain sight.

Apache Kafka is the core of an amazing ecosystem of tools and frameworks that enable us to get more value from our data. Let's take a journey through this wonderful world and see what we can learn.

In this session, we'll have a gentle introduction to Apache Kafka, and then a survey of some of the more popular components in the Kafka ecosystem. We will be looking at the Kafka Producer and Consumer libraries, Kafka Connect, Kafka Streams, the Confluent Schema Registry, and ksqlDB. You will leave loaded with ideas of ways to put Kafka to use in your organization, and a list of resources to help you on your journey.

Albert Einstein once said — “We cannot solve our problems with the same thinking we used when we created them.”

As developers, architects, managers, tech-leads, our job entails solving big problems. However, our systems are composed of parts, and it is the interaction of those parts that ensure the system works, and tells us where to go looking when things fail. What does it mean to think in systems? What are the benefits, and what are tools are available to us? If any of this intrigues you (and it should) come join me as we explore a new way of thinking about problems, both big and small.

In this session we will take a page from Donella H. Meadows fantastic book “Thinking in Systems” and attempt to get an understanding of what makes up a system, how we can tease apart the moving parts of the system, and get into the mindset of a “systems thinker”.

As a software architect, you're at the forefront of building scalable, secure, and resilient systems that drive innovation while safeguarding critical digital assets. This workshop is designed to equip you with actionable strategies, cutting-edge tools, and deep technical insights into embedding security into every phase of the software development lifecycle.
In this immersive, hands-on session, we will explore how to elevate your DevSecOps practices to meet the challenges of today’s evolving threat landscape while ensuring productivity and operational excellence.

What You'll Learn:

Integrating Security into CI/CD Pipelines: Discover how to build efficient, secure workflows that empower teams to deliver faster without compromising security. Learn to implement security gates and automate vulnerability detection with tools like SAST, DAST, and dependency scanning.
Tracking Metrics for Success: Understand key DevSecOps metrics such as lead time, deployment frequency, mean-time-to-recover (MTTR), and change fail rate. Learn how observability tools provide actionable insights to optimize performance and reliability.
Proactive Security with Ethical Hacking: Dive into penetration testing and simulate real-world attacks to uncover vulnerabilities in your systems before attackers do. Get hands-on with industry-standard tools such as OWASP ZAP.
OWASP Top 10 for Applications, APIs, LLMs, and Mobile:
- Applications: Learn to identify and mitigate risks such as injection flaws, broken authentication, and misconfigurations.
- APIs: Secure APIs with best practices for authorization, schema validation, and rate limiting to combat vulnerabilities like excessive data exposure.
- LLMs: Explore unique challenges in securing Large Language Models (AI-driven applications), including prompt injection and data leakage.
- Mobile: Address mobile app vulnerabilities such as insecure storage and transport layer protection, ensuring your applications are robust across platforms.
Aligning Security with Business Outcomes: Bridge the gap between technical practices and business goals by aligning DevSecOps with operational KPIs. Demonstrate how secure development drives measurable business value, customer satisfaction, and operational excellence.

Why You Should Attend:

Hands-On Experience: Participate in live demonstrations of vulnerabilities, attacks, and their mitigation across applications, APIs, LLMs, and mobile systems.
Cutting-Edge Tools and Techniques: Gain exposure to the latest tools and practices in CI/CD, ethical hacking, and observability.
Business-Driven Approach: Learn how to connect DevSecOps efforts to organizational success, making security an enabler of productivity.
Collaborate with Experts: Engage with peers and experts to discuss real-world challenges and share actionable solutions.

Who Should Attend:
This workshop is ideal for:

Software Architects seeking to embed security into every layer of system design.
Senior Developers striving to deliver secure, high-performing applications.
Technical Leads responsible for ensuring compliance and operational excellence in development pipelines.

Join us for this transformative session to gain the skills and knowledge necessary to design secure, scalable, and resilient systems that protect your organization and enable innovation.

Salient Points Architects Will Learn in This Talk

Shift-Left Security: Embed security early in the CI/CD process to catch and resolve vulnerabilities proactively.
Key DevSecOps Metrics: Track and optimize lead time, deployment frequency, MTTR, and change fail rate for operational excellence.
Ethical Hacking: Learn how to simulate real-world attacks to identify and fix vulnerabilities before they become threats.
OWASP Top 10 Insights: Gain actionable strategies to mitigate risks across applications, APIs, LLMs, and mobile platforms.
API Security Best Practices: Implement schema validation, token-based authentication, and rate limiting to safeguard APIs.
AI Security for LLMs: Address unique vulnerabilities in Large Language Models, including prompt injection and data leakage.
Mobile App Security: Protect mobile systems from insecure data storage and transport vulnerabilities using OWASP Mobile Top 10.
Business Alignment: Connect DevSecOps practices to measurable business KPIs, demonstrating security’s value in driving success.

This session is a must-attend for architects aiming to design secure, scalable systems while staying ahead in the rapidly evolving security landscape.

We are all proud of being the best coders, but have we analyzed our code for optimization? What tools can help us guide toward creating algorithms with better time and space complexity?

How you approach a problem is critical. How do you solve the problem? How do you optimize the problem?

This talk will not only prepare you for the interviews but will also give confidence on how to crack the coding challenges.

In this talk, we will be exploring analytical skills and coding skills of the top algorithms and common problems from the real-world, including

Single Source Shortest Paths
Traveling Salesman problems
Pattern Search Algorithms
Greedy Algorithms
KnapSack problem
Priority queue

Problem-solving skills are valuable and help develop optimal algorithms. We will look at problem-solving flow charts to make the right decisions for a given problem.

Topics we will cover are:

Arrays and Strings - Palindrome permutations
Linked Lists - Runner technique, Recursions
Stacks and queues
Trees and Graphs - Binary Tree, Binary Search Tree, Tries
Sorting and Searching
Single-Source Shortest Paths: Bellman-Ford, BFS, DFS, Dijkstra, Dynamic Programming

This talk is ideal for the following roles:

Architects
Technical Leads
Programers
Integration Architects
Solution Architects

Secure, Efficient, Resilient, High-performing, Sustainable, and Cost-effective

Are your applications well-architected? This talk will explore the best practices for operational excellence, Security, Reliability, Performance Efficiency, and cost optimization. Think of systems and services which provide business values. Do you know if all of these services are well-architected? You will learn how to create mechanisms, a repeatable process that allows you to improve over time. We will explore the best practices using real-world examples to make them more concrete and actionable.

Well-Architected helps cloud architects build secure, high-performing, resilient, and efficient infrastructure for various applications and workloads. They are built around six pillars—operational excellence, security, reliability, performance efficiency, cost optimization, and sustainability.

Join expert Rohit Bhardwaj to gain the knowledge and skills you need to solve current cloud implementation problems.

What you'll learn — and how you can apply it
By the end of this live, hands-on, online course, you'll understand the following:

– How to create responsive, maintainable, extensible architecture

– How to manage identities for people and machines and understand the significance of role-based, service-based, and attribute-based access

– How to design network topology and protect your network resources

– How to design interactions in a distributed system to prevent failures and improve performance and resiliency

– How to select the best-performing architecture and choose performant storage and databases

– How to manage demand and supply resources

– How to take advantage of user behavior patterns to support your sustainability goals

Topics covered:

Design Principles

– Scaling patterns

– Architecture Design Principles

– Capacity calculations

– Impact of data on design decisions

– Shared Responsibility Model

Reliability

– Resilient Architecture principles

– Herds of complex real-time distributed systems

– Hands-on Exercises / Case Studies

– Blast radius- fault isolation to protect your workload

– Availability patterns

– Recovery Point Objective and Recovery Time Objectives

– Data backup data patterns

– Routing Strategies

– Service quotas and constraints

– Design your workload service architecture

– Failure management in a distributed system

– Monitoring workload resources

– Calculating the response times

– Fallacies of Distributed Systems

– Testing reliability

– Cost Optimization

– Design cost-optimized storage

– Cost-optimized compute

– Data transfer costs

– Manage demand and supply resources

– Hands-on Exercises / Case Studies

Sustainability
– User behavior patterns

– Data access and usage patterns

– Development and deployment processes

– Hands-on Exercises / Case Studies

Performance Efficiency
– Select the best-performing architecture

– Choosing performant storage and databases?

– No-SQL for performance

– Caching strategies

– DOS attacks

– Tradeoffs to improve performance

– Evolving your workload

– Handle skewed data

– CDN networks like Cloudfront to solve the caching requirements for static and Dynamic
contents

– Monitor and set alarms for performance and network issues

– Hands-on Exercises / Case Studies

Operational Excellence
– Principles for Perform Operation Infrastructure as code

– Annotate Documentation - PlayBooks - Part of code

– Create Runbooks - Server down

– Capture failures and analyze them using Events and Real-Time Actions

– KPIs for cloud dashboard

– Incidence response - Root Cause Analysis

– Hands-on Exercises / Case Studies

Security, Privacy, and Compliance
– Manage identities for people and machines

– Identify Access Management

 Role-Based, Service-Based, and Attribute-Based Access

– Securely operate your workload.

– Detect and investigate security events

– Web Application Firewall

– Virtual Private Cloud - design network topology

– Protecting your network resources

– Bastion Hosts

– Data classification

– Protecting data in Transit

– Protecting data at Rest

Hands-on Exercises / Case Studies