Designing Microservices: From Architecting to Data Modeling

How does designing Microservices differ from designing more traditional applications?

What is a better way to learn than to take a problem, analyze the requirements, explore the design options, apply the concepts of bounded context, and arrive at the architecture and design of Microservices to realize the requirements?

Come to this workshop to get a practical, hands-on practice to navigate from requirements all the way to a workable solution and along the way learn about different architectural goals and approaches that can help with the design.

Journey into Architectural Design Patterns

In this day-long work workshop, we will walk through a catalog of all the common architectural design patterns. For each design pattern, we will run docker-compose files that demonstrate the strengths and weaknesses of those design patterns. So you have a first-hand, full-on, and highly engaged full-day workshop to give you the knowledge you need to make critical architectural choices.

We will cover:

• Anti-corruption-layer
• Claim Check
• CQRS
• Gatekeeper
• Strangler Fig
• Bulkhead
• More …

API Design

Application Programmer Interfaces (APIs) by definition are directed at software developers. They should, therefore, strive to be useful and easy to use for developers. However, when engaging design elements from the Web, they can be useful in much larger ways than simply serializing states in JSON.

There is no right or perfect API design. There are, however, elements and choices that induce certain properties. This workshop will walk you through various approaches to help you find the developer experience and long-term strategies that work for you, your customers and your organization.

We will cover:

The Web Architecture as the basis of our APIs
The REST Architectural Style and its motivations
The Richardson Maturity Model as a way of discussing design choices and induced properties
The implications of contentnegotiation and representation choices such as JSON or JSONLD
The emergence of metadata approaches to describing and using APIs such as OpenAPI and HydraCG
Security considerations
Client technologies
API Management approaches

Upgrade to Modern Java: 2025 Deep Dive

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.

Next Gen Spring Boot 2023 Edition featuring Spring 6

The Spring Framework transformed enterprise Java development nearly two decades ago, making it easier to achieve common things such as transactions, security, loose-coupling, and much more Over the years, Spring has continued to rise to every challenge Java developers face, most recently addressing subjects such as reactive programming, cloud computing, and container deployment in Kubernetes. Meanwhile, Spring Boot makes easy work of Spring by employing (among other things) auto-configuration, runtime insight and management, and a practical convention for specifying application properties.

The releases of Spring Framework 6 and Spring Boot 3 bring exciting and useful new capabilities. With features like native compilation, improved observability and tracing, support for HTTP problem details, and declarative HTTP clients, as well as baselining on Java 17 and Jakarta EE 9, Spring is ready for a new generation of application development.

In this workshop, you'll start with a very simple Spring Boot application and learn to grow it into a fully functional application including a web front-end and data persistence. And you'll get hands-on experience with some of the most exciting new features in Spring 6 and Spring Boot 3.

Mastering Enterprise Architecture to create Roadmap- DEEP DIVE

Enterprise Architecture helps in describing what is the current state and helps build a future roadmap. Come prepared to solve many Enterprise Architecture challenges.

As part of the journey, we will explore TOGAF to build our architecture. First, we will create a Baseline Architecture. Next, we will explore the path for the Target Architecture. Finally, after identifying gaps between the two, we will apply a step-by-step process to prepare a roadmap.

“Organizations no longer want their enterprise architecture (EA) practice to be focused on standards, structure and control,” says Marcus Blosch, research vice president at Gartner.

“They want an EA practice that is focused on driving business outcomes, working in a flexible and creative way to help define the future and how to get there.”

We will explore the following domains:

– Data

– Technology

– Application

– Business
This talk will help you build a long-term IT Strategy which matches your Business Strategy.

Foundations of Tech Leadership Deep Dive

According to a CareerBuilder study, only 40% of new tech leaders receive formal training when they become a boss for the first time. The rest are forced to get scrappy to quickly equip themselves with new skills, techniques, and mindsets to effectively transition into their new roles.

This workshop was designed to fill this gap; providing tactical techniques and resources for both new and seasoned technical leaders!

In this full day workshop, you will learn how successfully navigate the complexities of Engineering Management. Topics include:

Purposeful leadership, emotional intelligence, self awareness, time management, prioritizing the right things, social styles, giving feedback, career conversations, 1:1s, psychological safety, recruiting, interviewing, onboarding, measuring team metrics, motivation, engagement, team building, and building sustainable relationships.

Interactive group exercises will help you practice these new ideas and techniques in a safe and engaging environment.

You will leave with new perspectives on Engineering Management, as well as handouts and plenty of resources to grow and further develop skills in your daily work.

Please download (and print if possible) the handout before joining this workshop! (located with session slides).

Progressive Web App Workshop

Let’s connect with PWAs! Progressive Web Apps seek to bridge the gap between native Android & iOS apps and the Web. Learn about the APIs available in today’s mobile devices that enable you to leverage web technologies to deliver app-like experiences without having to write a line of Kotlin or Swift.

We’ll cover many of the APis that make Progressive Web Apps possible while building a dating web app for cats. Topics include:

• Installable PWAs
• Offline mode with Service Workers
• Geolocation
• Capturing photos from the camera
• Photo uploading
• Voice recordings
• Push Notifications

You’ll leave this full-day workshop armed with the hands-on experience to deliver a PWA that starts fast and stays fast.

GitHub Actions Deep Dive

In this full-day workshop, open-source author, trainer, and DevOps director Brent Laster will provide an extensive introduction to GitHub Actions. You’ll learn about the core parts and pieces that make up an action, as well as the types of functionalities and features they provide.
You’ll also see how to combine them in simple workflows to accomplish basic tasks as well as more advanced workflows to automate typical CI/CD and other tasks. And you’ll learn about
how to create and use your own actions, create and manage artifacts, and how to debug and secure your GitHub Action workflows.

This course will leverage hands-on, guided labs using GitHub and GitHub Actions so that participants can gain “real-world” experience with GitHub Actions.”

Advanced Git

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.

Advanced Kubernetes – Gaining Mastery over your Deployments

In this ½ day course, author and trainer and DevOps Director Brent Laster will take you beyond the basics of Kubernetes to understand the advanced topics you need to know to ensure your success with K8S.

In plain and simple explanations and hands-on labs, you’ll learn about key concepts such as RBAC, admission controllers, affinity, taints and tolerations mean and how to use them. You’ll learn tips to debug your Kubernetes deployments and how to leverage probes to ensure your pods are ready and healthy – and what happens when they aren’t.

Along the way, we’ll give you hands-on experience and time to play with these concepts in a simple minikube environment running on your own virtual machine that you can keep as a reference environment after the course.

Creating Architectural Fitness Functions using ArchUnit

In this workshop, take a practical approach to creating fitness functions that assess the architectural soundness of your systems.

We will learn about different fitness functions that can help architects and their teams create and comply with the architectural expectations expressed by their architect in collaboration with the team. Then we’ll see how we can implement those constraints, as guardrails, using ArchUnit, and get a continuous feedback on the teams' efforts.

Creating Evolutionary Architecture and Design: From Problem to Solution by exploring patterns

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.

DDD and Microservices

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.

Developer To Architect

Becoming a software architect is a longed-for career upgrade for many software developers. While the job title suggests a work day focused on technical decision-making, the reality is quite different. In this workshop, software architect Nathaniel Schutta constructs a real world job description in which communication trumps coding.

Discover the skill sets needed to juggle multiple priorities, meetings, and time demandsLearn why your best team leadership tool is not a hammer, but a shared cup of coffeeHear the best ways to give and take criticismUnderstand the necessity of writing effective email and formal architecture documentsGet tips for delivering confident career-building presentations to any audienceReview essential techniques for stakeholder management and relationship buildingExplore the critical needs for architecture reviews and an effective process for conducting themThrough lecture and small group exercises, Nathaniel will help you understand what it means to be a successful architect. Working through various problems, attendees will have opportunities to think through architectural decisions and patterns, discuss the importance of non functional requirements and why architects cannot afford to practice resume driven design.

Dockerfiles and Docker build—A Deep Dive

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.

Hacking and Hardening Java Web APIs Workshop

According to Akamai, more than 80% of internet traffic is now web API calls and makes up 90% of a web application’s attack surface. With such a critical and vulnerable piece of your architecture, do you know your APIs are secure? Do you know how and if attackers are attempting to exploit your APIs?

This hands-on workshop teaches you how to identify and fix vulnerabilities in Java web APIs. Using an existing API, you will learn ways to scan and test for common vulnerabilities such as excessive data exposure, broken authentication & authorization, lack of resource & rate limiting, and more. You will learn best practices around logging, intrusion detection, rate limiting, authentication, and authorization. You will also learn how to improve security in your APIs using existing tools, libraries, frameworks, and techniques to prevent vulnerabilities.

IntelliJ Dojo Deep Dive

Remember in the Matrix, when Neo said “I know Kung Fu”, and then Morpheus said “Show me”, well we will be doing that except with IntelliJ. In this dojo, we will be using all the wonderful keymappings that are available in IntelliJ and we will make you a lean mean coding machine!

In this dojo, you will master the art of:

• Code Generation
• Fast Navigation
• Multicursor Handling
• Refactoring Techniques
• Enhance your Git Prowess
• Code Complete
• Get Documentation
• Perform Column Selection Mode
• Dazzle with Emmet

“Show no weakness, Show no mercy”

Kafka Fundamentals

Kafka is a “must know.” It is the data backplane of the modern microservice architecture. It's now being used as the first persistence layer of microservices and for most data aggregation jobs. As such, Kafka has become an essential product in the microservice and big data world.

This workshop is about getting started with Kafka. We will discuss what it is. What are the components, we will discuss the CLI tools, and how to program a Producer and Consumer.

Latest Features in Java

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

Machine Learning Workshop

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

Mastering Cloud Scalability and System Designs Workshop

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

Mastering Modern JavaScript

Today, JavaScript is ubiquitous. However, for the longest time, JavaScript for the longest time was deemed quirky and eccentric. Developers had to resort to convoluted programming practices and patterns to avoid the potholes presented by the language.

All that changed in 2015. The central committee that governs the development of the language
announced a slew of changes aiming to propel JavaScript into a new era. Features like let and const aim to deprecate the mischievous var, while fat-arrow functions aim to not only make JavaScript more succinct but also more functional. Developing domains and object hierarchies is also easier using the newly introduced classes. Finally features like promises and async/await make it easier to work with asynchronous operations.

However, there is a ton of legacy code out there that still uses older language constructs, and this code needs to be and should be refactored to use modern JavaScript constructs. This not only makes the code sustainable and evolvable but also clearer, more explicit, and lesser bugs.

In this exercise-driven workshop, you will use a test-driven approach to learn how to safely refactor your legacy JavaScript code using modern constructs.

By the end of this workshop, you will have built a solid foundation of modern JavaScript constructs. You will be ready to take on your next project or refactor an existing one with confidence.

Node.js Deeper Dive

You’ve taken your first steps into Node.js. You’ve learned how to initialize your projects, you’ve played with some dependencies, and you’re ready to get into some serious Node work.

In this session, we’ll dive further into Node as a framework. We’ll learn how to master Node’s inherently asynchronous nature, take advantage of Node’s events and streams capabilities, and learn about sophisticated Node deployments at scale. Participants will leave with a richer understanding of what Node has to offer and higher confidence in dealing with some of Node’s more difficult concepts.

Refactoring Code: An Incremental and Purpose Driven Approach

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.

Spock Workshop - A MUST Have for your Developer Toolbelt

Spock is a groovy based testing framework that leverages all the “best practices” of the last several years taking advantage of many of the development experience of the industry. Combine Junit, BDD, RSpec, Groovy and Vulcans… and you get Spock! Feedback from previous attendees experienced with Spock indicated they learned more than they imagined they would as this deep dive session will explore many less documented cases of Spock and is intended for all experience levels.

This workshop assumes some understanding of testing and junit and builds on it. We will introduce and dig deep into Spock as a test specification and mocking tool. This is a hands-on 50% labs workshop. Concepts are presented, followed by labs to help re-enforce understanding.

Spring Graph QL

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.

Spring into K8s: Deploying Spring Application in Kubernetes

Although Java originally promised write once, run anywhere, it failed to fully deliver on that promise. As developers, we can develop, test, and build our applications into WAR or executable JAR files and then toss them over the wall to a Java application server and Java runtime that we have no control over, giving us zero confidence that the application will behave the same as when we tested it.

Containers fulfill the write-once, run anywhere promise that Java wasn't able to, by packaging the runtime and even the operating system along with our application, giving greater control and confidence that the application will function the same anywhere it is run. Additionally, containers afford several other benefits, including easy scaling, efficiency in terms of resource utilization, and security by isolating containers from their host system and from other containers.

While deploying Spring applications in containers has always been possible, Spring Boot makes it easier to containerize our applications and run them in container architectures such as Kubernetes. Spring Boot's support for containerization includes two options: Creating containers based on buildpacks or using layers as a means of modularizing and reducing the size of our application deployments. Moreover, new components in the Spring ecosystem can make your Spring applications Kubernetes-savvy so that they can take advantage of what a containerized architecture has to offer.

In this example-driven session, we're going to look at how to create and deploy Spring applications as container images and deploy them into a Kubernetes cluster. Along the way, we'll also get to know a few of the most useful tools that a Spring developer can employ in their development workflow when building containerized Spring applications. We'll also see how to apply patterns of Spring Cloud–such as configuration, service discovery, and gateways–using native Kubernetes facilities instead of Spring Cloud components. And we'll look at how components of the Spring ecosystem can work with your Spring applications to enable them to thrive in a Kubernetes cluster.

Succeeding With Microservices

These days, you can’t swing a dry erase marker without hitting someone talking about microservices. Developers are studying Eric Evan’s prescient book Domain Driven Design. Teams are refactoring monolithic apps, looking for bounded contexts and defining a ubiquitous language. And while there have been countless articles, videos, and talks to help you convert to microservices, few have spent any appreciable time asking if a given application should be a microservice. In this talk, I will show you a set of factors you can apply to help you decide if something deserves to be a microservice or not. We’ll also look at what we need to do to maintain a healthy micro(services)biome.

Microservices demand more than just a new architecture, they require a cultural shift. In this workshop, we'll cover:

• A set of principles that will help you decide if microservices are the best choice for your applications
• How to build production-hardened services
• How to empower your teams while ensuring they make good decisions
• How to develop a cloud native culture
• The challenges and pitfalls of microservice architectures and how to manage them

Top Algorithms for Performance and Efficiency

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

Top Algorithms for Performance and Efficiency

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