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.

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

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.

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

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.

As developers we not only operate in different contexts, but also often have these different contexts interplay as part of our work.
Each of the tools that we use — version control systems like Git (along with collaborative tools like Github/Gitlab), IDE's like Eclipse/IntelliJ, build systems like Gradle, Ci/Cd tooling like Jenkins, IaaC tools like Ansible, the command line — all introduce context.

To be effective developers we need to know when to operate in a certain context, combine or tease apart how these contexts interplay.
Can you improve your release announcements if format your commit messages consistently? You bet!
How should your build tool interact with your version control system?
What does naming your files have to do with how you use your IDE?

This session will take a look at several of these contexts — it will attempt to discern between them, explore when you should separate them and when you attempt to bring them together.

With lots of examples, and lots of quizzes this session will definitely leave you thinking about a few things.

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 domain-driven 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.

We will also discuss the “tactical” patterns of DDD — We will see how we can “embed” the ubiquitous language in code, and the architectural influences of DDD.

This workshop will have you thinking about how to think in DDD using DDD concepts and ideas. Using polls, and mini-exercises we attempt to better cement the ideas of DDD so we can start applying them at work.

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 domain-driven 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.

We will also discuss the “tactical” patterns of DDD — We will see how we can “embed” the ubiquitous language in code, and the architectural influences of DDD.

This workshop will have you thinking about how to think in DDD using DDD concepts and ideas. Using polls, and mini-exercises we attempt to better cement the ideas of DDD so we can start applying them at work.

Spring has always been defined by its lightweight core. While there has been an overwhelming explosion in the external projects and protocols it integrates seamlessly with, it has also evolved internally to meet the needs of modern development requirements.

One of the biggest changes in the last several years has been the emergence of Reactive Spring, an attempt to embrace the idea of Reactive Systems in the Spring ecosystem. This is a vision of responsive, resilient, elastic systems. Unfortunately, code alone cannot solve the problems so this is a case where software and architecture meet.

You will learn about:

- The Reactive System vision
- How Spring absorbed these ideas without complicating or
  eliminating the more conventional styles
- How to build, test and consume Reactive Spring applications
- How to architect entire Reactive chains of interacting systems

Spring has always been defined by its lightweight core. While there has been an overwhelming explosion in the external projects and protocols it integrates seamlessly with, it has also evolved internally to meet the needs of modern development requirements.

One of the biggest changes in the last several years has been the emergence of Reactive Spring, an attempt to embrace the idea of Reactive Systems in the Spring ecosystem. This is a vision of responsive, resilient, elastic systems. Unfortunately, code alone cannot solve the problems so this is a case where software and architecture meet.

You will learn about:

- The Reactive System vision
- How Spring absorbed these ideas without complicating or
  eliminating the more conventional styles
- How to build, test and consume Reactive Spring applications
- How to architect entire Reactive chains of interacting systems

Machine Learning is all the rage, but many developers have no idea what it is, what they can expect from it or how to start to get into this huge and rapidly-changing field. The ideas draw from the fields of Artificial Intelligence, Numerical Analysis, Statistics and more. These days, you'll generally have to be a CUDA-wielding Python developer to boot. This workshop will gently introduce you to the ideas and tools, show you several working examples and help you build a plan to for diving deeper into this exciting new field.

We will cover:

• The differences between data science, AI and machine learning
• The Five Tribes of Machine Learning (as defined by Pedro Domingos)
• Walkthroughs of some of the main algorithms
• Examples in Java, R and Python
• Tools such as Tensorflow and Pytorch
• The impact of GPUs on machine learning
• Stories about how companies are being successful with machine learning
• A discussion about the likely impacts of machine learning on the job market and society

Workshop Requirements

Please install Anaconda for Python 3 before the workshop if possible. https://www.anaconda.com/download

Machine Learning is all the rage, but many developers have no idea what it is, what they can expect from it or how to start to get into this huge and rapidly-changing field. The ideas draw from the fields of Artificial Intelligence, Numerical Analysis, Statistics and more. These days, you'll generally have to be a CUDA-wielding Python developer to boot. This workshop will gently introduce you to the ideas and tools, show you several working examples and help you build a plan to for diving deeper into this exciting new field.

We will cover:

• The differences between data science, AI and machine learning
• The Five Tribes of Machine Learning (as defined by Pedro Domingos)
• Walkthroughs of some of the main algorithms
• Examples in Java, R and Python
• Tools such as Tensorflow and Pytorch
• The impact of GPUs on machine learning
• Stories about how companies are being successful with machine learning
• A discussion about the likely impacts of machine learning on the job market and society

Workshop Requirements

Please install Anaconda for Python 3 before the workshop if possible. https://www.anaconda.com/download

This workshop discusses the features added to Java since Java 8. After a review of the functional additions (streams, lambda expressions, and method references), topics will include Local Variable Type Inference (LVTI), collection factory methods, the Java shell, the new HTTP client, the enhanced switch statement, text blocks, records, pattern matching, and sealed classes.

Features will be demonstrated for Java versions from 8 through 17, using preview versions where available.

• Java Licensing and Release Schedule
• Functional Programming in Java
  • Lambda expressions
  • Method references
  • Streams
  • Optional data type
  • Static and default methods in interfaces
• The java.time Package
• Collection Factory Methods
  • List.of
  • Set.of
  • Map.of
  • Map.ofEntries
• Local Variable Type Inference
• JShell
• HTTP Client
• Enhanced Switch Statement
• Text Blocks
• Records
• Pattern Matching
• Sealed Classes
• Miscellaneous Features
• A bit about JPMS

This workshop discusses the features added to Java since Java 8. After a review of the functional additions (streams, lambda expressions, and method references), topics will include Local Variable Type Inference (LVTI), collection factory methods, the Java shell, the new HTTP client, the enhanced switch statement, text blocks, records, pattern matching, and sealed classes.

Features will be demonstrated for Java versions from 8 through 17, using preview versions where available.

• Java Licensing and Release Schedule
• Functional Programming in Java
  • Lambda expressions
  • Method references
  • Streams
  • Optional data type
  • Static and default methods in interfaces
• The java.time Package
• Collection Factory Methods
  • List.of
  • Set.of
  • Map.of
  • Map.ofEntries
• Local Variable Type Inference
• JShell
• HTTP Client
• Enhanced Switch Statement
• Text Blocks
• Records
• Pattern Matching
• Sealed Classes
• Miscellaneous Features
• A bit about JPMS

The fundamental testing libraries in Java have undergone complete redesigns in the past few years. JUnit 5, known as JUnit Jupiter, redesigns the most well-known tool in all of testing. This talk will demonstrate the new features, how they are intended to be used, and discuss experimental ideas in the pipeline.

JUnit has been remarkably stable over the years and is one of the most widely adopted frameworks in the Java world. The latest version, JUnit 5, takes JUnit to the next level. Full of new features like conditional test execution, parametric testing, labeling and filtering tests, and more, it brings all the modern thinking on testing into the JUnit world. It also takes advantage of the functional features added to Java since version 8 to create a powerful, new library for testing your code.

The Mockito framework is the most popular library for creating mocks, stubs, and spies for your tests. This talk reviews why and how you might want to do that, including unit vs integration tests, creating your own mocks and stubs, setting expectations, and verifying the results.

The Mockito documentation is notoriously misleading if you don't already know the principles behind the library. This talk gives an example that hopefully clears up any confusion and makes the docs useful. Many examples will be provided covering a wide range of capabilities. In addition to the basics, issues like mocking static methods, mocking final methods and classes, using spies for existing classes, and more will be examined.

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.

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.

In this example-driven session, we're going to look at how to implement GraphQL in Spring. You'll learn how Spring for GraphQL builds upon GraphQL Java, recognize the use-cases that are best suited for GraphQL, and how to build a GraphQL API in Spring.

Typical REST APIs deal in resources. This is fine for many use cases, but it tends to be more rigid and less efficient in others.

For example, in an shopping API, it's important to weigh how much or how little information should be provided in a request for an order resource? Should the order resource contain only order specifics, but no details about the order's line items or the products in those line items? If all relevant details is included in the response, then it's breaking the boundaries of what the resource should offer and is overkill for clients that do not need it. On the other hand, proper factoring of the resource will require that the client make multiple requests to the API to fetch relevant information that they may need.

GraphQL offers a more flexible alternative to REST, setting aside the resource-oriented model and focusing more on what a client needs. Much as how SQL allows for data from multiple tables to be selected and joined in response to a query, GraphQL offers API clients the possibility of tailoring the response to provide all of the information needed and nothing that they do not need.

Workshop Requirements

• Java (17 or higher)
• An IDE of your choosing (I'll be using either Spring Tools or IntelliJ, but VSCode or even NetBeans will be fine if you prefer)

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.

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.

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.

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!

Over the past few years, the basic idioms and recommended programming styles for Java development have changed. Functional features are now favored, using streams, lambda expressions, and method references. The new sixmonth release schedule provides the language with new features, like modules and local variable type inference, much more frequently. Even the new license changes in the language seem to complicate installation, usage, and especially deployment.

The purpose of this training course is to help you adapt to the new ways of coding in Java. The latest functional approaches are included, including using parallel streams for concurrency, and when to expect them to be useful. All the new significant features added to the language will be reviewed and evaluated, with the goal understanding what problems they were designed to handle and when they can be used effectively in your code.

Workshop Requirements

The workshop will use Java 21. You can get that from any major vendor, including Oracle. If you don't have a preferred vendor, then https://adoptium.net/ offers pre-built OpenJDK binaries for free.

We'll use IntelliJ IDEA for coding, but nothing in the materials requires any particular IDE. Only the Community edition is necessary, though the instructor will be using the Ultimate edition.

We will also use Gradle as our build tool, but most of the major IDEs can create Gradle-based Java projects without additional installs. You are welcome to use Maven if you prefer, but the instructor may not be able to help if you run into issues.

Over the past few years, the basic idioms and recommended programming styles for Java development have changed. Functional features are now favored, using streams, lambda expressions, and method references. The new sixmonth release schedule provides the language with new features, like modules and local variable type inference, much more frequently. Even the new license changes in the language seem to complicate installation, usage, and especially deployment.

The purpose of this training course is to help you adapt to the new ways of coding in Java. The latest functional approaches are included, including using parallel streams for concurrency, and when to expect them to be useful. All the new significant features added to the language will be reviewed and evaluated, with the goal understanding what problems they were designed to handle and when they can be used effectively in your code.

Workshop Requirements

The workshop will use Java 21. You can get that from any major vendor, including Oracle. If you don't have a preferred vendor, then https://adoptium.net/ offers pre-built OpenJDK binaries for free.

We'll use IntelliJ IDEA for coding, but nothing in the materials requires any particular IDE. Only the Community edition is necessary, though the instructor will be using the Ultimate edition.

We will also use Gradle as our build tool, but most of the major IDEs can create Gradle-based Java projects without additional installs. You are welcome to use Maven if you prefer, but the instructor may not be able to help if you run into issues.

Genetic algorithms are a nonlinear optimization technique. They encode a set of solutions, called a population, that are evaluated using a fitness function. Successful solutions are chosen to form new solutions, called offspring, through a process called crossover. In each generation, random mutations are introduced as well, to maintain a good level of genetic diversity. In addition to the basic concepts, examples will be shown in Java using the Jenetics library.

This talk will show several problems that are ideally suited to genetic algorithms, including the Traveling Salesman Problem, Ant Colony Optimization, the Knapsack Problem, and more.

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.

Gradle has been described as the open source project with the most documentation that doesn't help. Key concepts, like the different steps Gradle takes at initialization time, configuration time, and execution time are not obvious, but must be understood to use Gradle effectively. This talk will cover those topics, as well as how to use source sets, IDE integration, testing in parallel, the build cache, and multi-project builds.

New topics to be included based include writing your own custom tasks, using version constraints, archiving and expanding files and folders, and incremental builds for efficiency.

Recently revised to include dependency conflict resolution, lazy task creation, the TOML file for versioning, and more.

Knowledge graphs are a rapidly emerging concept for machine-processable models of complex and dynamic domains. They represent the intersection of Web architecture and information. If your organization wants to resolve its most pernicious data integration problems or facilitate machine learning initiatives, knowledge graphs are likely to be part of your future.

We will discuss the emergence of Knowledge Graphs as an emerging solution to a missing capability in most organization's IT strategies. We will discuss how some of the biggest organizations in the world are heading in this direction, it's impact on API design and more. We will focus on specific tools, platforms and standards that are making Knowledge Graphs a crucial part of your overall solutions.

A Docker image is the artifact of the container world. Leaner images allow easier for quicker build times, less resource management (disk pressure and network usage), fewer attack vectors, and better performance when pulling or pushing images for storage or upon deployment. Lean images also produce smaller containers, which in turn require fewer resources at runtime, allowing for higher server density. Multistage Dockerfiles can help reduce the complexity of CI/CD pipelines by reducing the number of moving parts in building, testing, and producing a production-grade image. The key to building leaner (smaller) images, with little build-time overhead is to understand how Docker uses the Union File System (UFS), how Docker builds (and when it busts) the cache, and how to use the Dockerfile specification to it's fullest potential.

In this exercises driven, hands-on workshop, we will dive deep, peeking under the hood to get a glimpse of the Union File System, and then proceed to look at the effects of many of the important Dockerfile instructions. We will see how best to use them, and highlight any caveats that we should be aware of.

By the end of this class you will have gained a keen understanding of how best to write your Dockerfiles, and effectively build and design lean images, and containers.

A Docker image is the artifact of the container world. Leaner images allow easier for quicker build times, less resource management (disk pressure and network usage), fewer attack vectors, and better performance when pulling or pushing images for storage or upon deployment. Lean images also produce smaller containers, which in turn require fewer resources at runtime, allowing for higher server density. Multistage Dockerfiles can help reduce the complexity of CI/CD pipelines by reducing the number of moving parts in building, testing, and producing a production-grade image. The key to building leaner (smaller) images, with little build-time overhead is to understand how Docker uses the Union File System (UFS), how Docker builds (and when it busts) the cache, and how to use the Dockerfile specification to it's fullest potential.

In this exercises driven, hands-on workshop, we will dive deep, peeking under the hood to get a glimpse of the Union File System, and then proceed to look at the effects of many of the important Dockerfile instructions. We will see how best to use them, and highlight any caveats that we should be aware of.

By the end of this class you will have gained a keen understanding of how best to write your Dockerfiles, and effectively build and design lean images, and containers.

Cloud native applications are distributed to reap the benefits of resource scaling. Distributed computing is powerful but it also makes you think differently in designing applications. Atomic, modular, highly cohesive, and low coupled applications play nicely on these distributed systems. But it comes with costs.

We’ll look at architecture styles that adapt well to running in containers and on Kubernetes. Along the way, we’ll note the extra things your application should do to play nicely with distributed cloud native targets.

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”.

Real-world applications nowadays are designed using both art and science. What is the process of coming up with a solution which works, scales, and is resilient?
What is it challenging to design a system for disruptive technologies?
System design is unstructured, and there are many ways to solve problems.
Gaining experience in new applications and technologies
Best practices change with time. The best way ten years ago can quickly become an anti-pattern.

In this talk, we will explore step by step guide to approach System design using real-world applications.

Come prepared to design a system for following applications interactively.

We will gain more knowledge with collective experience and best practices.

• UBER System Design

• NETFLIX System Design

• INSTAGRAM System Design

• YELP System Design

• TWITTER System Design

• Search Engines

• Auto Suggestions / Recommendations System Design

• Fraud Detection System Design

This talk is ideal for the following roles:

• Architects

• Technical Leads

• Programers

• Integration Architects

• Solution Architects

Real-world applications nowadays are designed using both art and science. What is the process of coming up with a solution which works, scales, and is resilient?
What is it challenging to design a system for disruptive technologies?
System design is unstructured, and there are many ways to solve problems.
Gaining experience in new applications and technologies
Best practices change with time. The best way ten years ago can quickly become an anti-pattern.

In this talk, we will explore step by step guide to approach System design using real-world applications.

Come prepared to design a system for following applications interactively.

We will gain more knowledge with collective experience and best practices.

• UBER System Design

• NETFLIX System Design

• INSTAGRAM System Design

• YELP System Design

• TWITTER System Design

• Search Engines

• Auto Suggestions / Recommendations System Design

• Fraud Detection System Design

This talk is ideal for the following roles:

• Architects

• Technical Leads

• Programers

• Integration Architects

• Solution Architects

Resilient architecture is fundamental when working in distributed, cloud-based systems. Designing and architecting large-scale applications managing millions of requests brings unique challenges with availability, performance, and integration. You will need to make difficult choices and evaluate tradeoffs. Luckily, you can use different architecture patterns to make a distributed application more resilient. Based on evolutionary architecture, this approach enables you to create systems designed to evolve with the ever-changing software development ecosystem. Resilient architecture patterns will allow you to create systems that continue functioning even when components fail.

Join expert Rohit Bhardwaj to learn how to implement an evolutionary architecture approach and understand resilient architecture patterns. This training will explore architecture decisions you may need to make when evaluating your architecture to improve performance and resiliency. For example, you will no longer struggle to handle millions of requests per second or face issues when routing traffic.
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 from resilient, elastic design utilizing message-driven services

How to design cost-effective Recovery Point Objectives (RPOs) and Recovery Time Objectives (RTOs)

How to identify blocking issues with microservices in the cloud

How to evaluate caching strategies that can help lower costs and protect from DOS attacks

And you'll be able to:

Design high availability, high scalability, low latency, and resilient architectures.

Analyze and review implementations.

Identify key scalability challenges in your company.

Prevent cascading failures and preserve functionality.

This training is for you because…

You have an existing need to evaluate your current architecture.

You want to understand best practices.

You need to design new systems and want to evaluate which pattern to use.

Prerequisites

Basic knowledge of software architecture

Familiarity with design principles

Thinking application as stateless for all the API calls makes the system available most of the time and requires creating a cache for common distributed data. Next, we examine how to deal with cascading failures and timeout scenarios. As part of auto-healing, applications need to Detect, Prevent, Recover, Mitigate, and Complement so that the service is resilient.

The key takeaways for the audience are as follows:

*Resiliency is essential for any feature in the cloud.

*Understanding the value chain is critical to identifying failure points.

*Challenges come in determining if there is a failure and designing the system for auto-
healing

*The focus should be first to prevent a failure from occurring.

*Identifying critical challenges in your company and tools and techniques to auto-heal and provide a sustainable solution

Course Schedule

Evolutionary Architecture:

– Scaling to 100 million customers

– Understanding Requirements - Empathy Map

– Fail Points

– Defining KPIs

Resilient Patterns:

– BulkHead pattern

– Routing Strategies

– Design Issues with Microservices

– API Gateway Pattern

– Database per Service Pattern

– Database Sharding Patterns

– Fan out Pattern

– Publish-Subscribe Pattern

– Command Query Responsibility Segregation (CQRS)

– Message filter pattern

– Topic-queue-chaining Pattern

– Message Partitioning Patterns

– Priority Queue Pattern

Caching:

– Caching and Failure Injection

– Distributed system challenges

– Caching Patterns

– Order in Chaos

– Resilient Steps

– Resources

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?

In this talk/workshop, we will be exploring the analytical skills and coding skills of the top algorithms and common problems from the real world, including Single Source Shortest Paths, Travelling Salesman problems, Pattern Search Algorithms, Greedy Algorithms, KnapSack problem, and 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.

Property-based testing (PBT) validates the expected behavior of a system by checking it against a range of data points. A well-chosen set of properties will give the user a lot of confidence that the system is behaving as expected. The idea is that when the code is modified, failures in the tests reveal problems that would not have been found otherwise. This talk will cover the basic principles and several examples of PBT, using the jqwik library.

PBT allows you to define invariants (like reversing a list twice should result in the original list) and verify that they hold given generated changes that include a wide range of random inputs, including edge and corner cases. The jqwik library works well with JUnit to provide an important part of your testing strategy.

Conflict between technical professionals and traditional managers is inevitable, because you want different things. Worse, most employees feel that when conflicts arise, their only options are either to go along with what the manager wants, or leave. Neither option gets you what you want when you want it.

This talk discusses a third option: how to build a relationship over time that makes your boss an ally. The goal is to build a productive relationship that allows you to push back against decisions you don't like, while maintaining a constructive, loyalty-based relationship that satisfies both sides. Topics will include the two messages to keep in mind whenever you interact with the boss, how to use solutions to the iterated Prisoner's Dilemma problem to resolve conflicts, how to structure communications in way most likely to be heard and understood, and more.

Knative is a container-oriented framework for “enterprise-grade serverless on your own terms.” Running in Kubernetes, on any cloud provider or your own data center, Knative offers two serverless capabilities: Serving and Eventing.

Serving is all about auto-scaling, not only up as load increases, but down as load drops off, including scaling all the way to zero.

This presentation is a gentle introduction to Knative.

In this talk, we will explore the following topics:

• What exactly is Knative?
• Getting started with Knative
• Introduction to Knative serving
• Exploring Knative eventing with CloudEvents for asynchronous event processing

You will leave this talk with a solid foundation of Knative basics and a headful of ideas on how your team can roll your own serverless solution using Knative.

Modern software development often leverages services of public cloud providers like AWS, Azure, and Google Cloud. Each vendor offers a robust set of web UIs and CLIs for infrastructure provisioning, but these are typically for one-off provisioning and don't allow for normal Software Development Lifecycle Processes like source control and code reviews.

This talk is a gentle introduction to Infrastructure as Real Code using an easy, but very capable, provider-agnostic tool called Pulumi.

Broadly speaking, Infrastructure as Code (IaC) solutions come in two categories. The first category uses a Declarative approach, typically using YAML or JSON. For AWS users, think CloudFormation. Also, approaches like Terraform, a very popular IaC toolchain from HashiCorp, offer a quasi-declarative approach with some richer dynamic capabilities. However, to a software developer, these all seem a bit foreign, using arcane, proprietary, and unfamiliar syntax and idioms.

Fortunately, the second category of IaC solutions uses an Imperative approach; i.e. real code like what developers are used to. To a development team, this can feel much more natural, fits into the normal SDLC processes, and offers many capabilities that will never be available from declarative IaC approaches.

This talk is a gentle introduction to Infrastructure as Real Code using an easy, but very capable, provider-agnostic toolchain called Pulumi.

In this talk, we will explore the following topics:

• A brief introduction to IaC
• Introduction to Pulumi concepts
• Provisioning our first set of resources on AWS
• Kubernetes is a Pulumi first-class citizen
• A brief look at some more advanced abstractions and automation patterns

You will leave this session armed with the basics of Infrastructure as Code with Pulumi, a few recipes to actually provision resources, and a much better appreciation for how your team can start building out infrastructure using real code.