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.

Kubernetes for Developers - 1 Day Deep Dive

Kubernetes is a rich infrastructure that helps you tackle the complexities of distributed computing. As a developer you want to understand how you can architect your code to take advantage of the whole data center for your scaling, load balanced, and resilient microservices.

This course is for software engineers (architects, developers, DevOps, administrators, testers) who want to move their solutions to microservices and containers running on cloud native, distributed container platforms. This introduction course covers the key techniques to automate, deploy, and manage containerized applications on Kubernetes.

These concepts are presented and reinforced with hands-on exercises:

• Advantages of cloud native distributed computing
• When Kubernetes is helpful and when it's not
• Accessing the large, active community
• Architecture and terms and how it works
• Deploying and running applications
• Resources galore: Deployment, Pods, ConfigMaps, Jobs, Secrets, Volumes, and more
• Composing Pod patterns
• Operator pattern
• Networking and meshes
• Observability
• Knative
• Maturity Model for cloud native success

While this is much to cover in a day you will leave with a solid understanding of how Kubernetes actually works and a set of hands-on exercises your can share with your peers.

Some knowledge of how to build containers will be helpful. Bring a simple laptop with a standard browser for a full hands-on experience.

Adaptive Technical Leadership

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

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.

Fundamentals of Software Architecture: Designing and Analyzing Software Systems

A good software architecture is the foundation for any successful software system. Your architectural choices affect almost every aspect of the software you are building from maintainability to stability, scalability and cyber vulnerability. Matching software architecture patterns and styles with requirements is a difficult task that requires knowledge and experience as well as the willingness to pick the right trade-offs.
Way too often the originally intended architecture erodes during the development process making the software harder to understand, to maintain and to adapt to changing requirements. By losing architectural coherence you also lose all the other benefits coming from a good architectural foundation. This drives up cost, reduces the happiness of your development team and ultimately will also impact the users of your software negatively.

Join expert Alexander von Zitzewitz to learn the foundations of good architecture. You’ll explore the concept of architecture styles and architectural fitness functions and dive into software metrics with architectural relevance. You’ll also investigate architectural smells like cyclic dependencies and bottleneck classes along with ways to refactor to prevent quality issues.

After learning the fundamentals, you’ll do some real code analysis using a free tool called Sonargraph-Explorer. Get hands-on with basic assessment and analysis techniques as well as techniques and methods for breaking up or restructuring monolithic applications—and measure your progress every step of the way. Then we will talk about how you can enforce architectural models during development and therefore avoid the common problem of architectural erosion in the first place. At the end, we will look at techniques to break up monolithic applications into more manageable pieces.

Machine Learning Data Pipelines

This workshop builds an entire event driven data pipeline with Machine Learning and Kafka. From Kafka where we use producers or Kafka Connect to generate information, we then will Kafka Streams to apply a machine learning model to make business decisions.

This intensive lab will start by integrating sources into our backplane, then train our models, and operationalize our model using Kafka Streams. We will then create result topics when we can read in as a report and display visualizations of our data. The result will also be scalable and fault tolerant.

The Treasure Map, Hands-On: Chart Your Way to Continuous Delivery

There is pain inherent in development - monoliths, confusing deployment processes, conflict between dev/ops/security/business… IT is complicated, and hard to do well, and the pace of change expected by customers makes it all even MORE difficult.

It can also be massively overwhelming to try to fix any of these pain points. A plan can help, but…how do you go about making that plan, and how do you share the plan with other people in a way that's easy to understand?

Join Josh and Laine as they talk about how to create a version of this map for your organization - by focusing on what you want to accomplish and the pain points in the way. You'll leave with a version of the problems in the way of accomplishing CD at your organization, along with some “huh, this isn't as overwhelming as it seemed before!”

This workshop will include a lot of discussion and interaction, and probably some feels!

AWS Certified Solution Architect workshop - Deep Dive

AWS Certified Architect is one of the hottest and most valuable certifications in 2021. Amazon Web Services is one of the most popular cloud platforms around.

Abilities Validated by the Certification are:

– Effectively demonstrate knowledge of how to architect and deploy secure and robust applications on AWS technologies.

– Define a solution using architectural design principles based on customer requirements

– Provide implementation guidance based on best practices to the organization throughout the life cycle of the project

In this workshop, we will explore the following topics with hands-on labs:

– Design using compute, networking, storage, and database AWS services, EC2, S3 storage, RDS, DynamoDB
– AWS deployment and management services, Cloud Formation, Identity Access Management
– API Gateway, Route 53
– Serverless architecture, AWS Lambda, Step Functions
– Simple Notification Service (SNS), Simple Queue Service(SQS)
– AWS Cloud Watch, AWS CloudTrail
– Identify and define technical requirements for an AWS-based application
– Recommended best practices for building secure and reliable applications on the AWS platform
– Architectural principles of building on the AWS Cloud
– AWS global infrastructure
– Network technologies as they relate to AWS, Virtual Private Cloud
– Security features and tools that AWS provides and how they relate to traditional services

This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects

Please get free tier AWS account from following link:
https://aws.amazon.com/

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

A QUIC Guide to the Past and Future of HTTP : Easy as 1, 2, 3

The Hypertext Transfer Protocol (HTTP) has been in use for decades. Almost as soon as it was released initially, those surrounding its design began extending it to meet the needs of evolving interaction styles.
HTTP 1.1 was a huge leap forward, but there were still performance issues that were not resolved until HTTP/2.

Now, we are on the cusp of the biggest changes to date with the introduction of HTTP/3 and QUIC. Developers need to understand what is happening so they can build modern, high performance Web-based systems that benefit from the new capabilities.

You will learn about:

- How HTTP has evolved over time
- What the major innovations and limitations have been along the way
- How HTTP/2 changed Web application and API design
- How HTTP/3 and QUIC will change Web application and API design
- How the co-evolution of TLS 1.3 combines with HTTP/3 and QUIC to
  modernize the secure Web

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.

AWS Lambda and Serverless Framework workshop

Modern applications are all built using Serverless Computing. Serverless is one of the top-paying cloud skills. In this talk, we will explore the AWS Serverless framework. Serverless architecture is a way to build and run applications and services without having to manage infrastructure.
You’ll learn Serverless Computing from beginning to end. We will take a deep dive into best practices, core features, and advanced features including step functions.

We will go over the following topics:
– AWS Lambda
– AWS API Gateway
– Amazon DynamoDB
– AWS Step Functions
– AWS SAM (Serverless Application Model)
– Serverless Framework design patterns
– AWS Continuous Integration Tools like Git, CodeCommit, CodeBuild, CodePipeline
Serverless Integrations Best Practices

Who will benefit from this course?
– Developers and Architects to discover AWS Serverless Lambda and the Serverless Architecture
– DevOps Professionals who want to understand CICD pipelines
– Developers or Architects who want to design serverless applications using the best practices in serverless computing

Prerequisites?
Have access to an AWS Account, some familiarity to AWS
JavaScript knowledge

This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects

Building and Deploying Cloud Native Applications with gRPC Kotlin & Kubernetes

In this hands-on workshop you will learn how to take a Cloud Native Application from inception to production. Starting with a base sample application we will learn how to break the application into separate services that communicate via gRPC Kotlin. We will then learn how to containerize and deploy the application to Kubernetes. Along the way we will learn how to address some of the major challenges of deploying applications to Kubernetes, such as scaling and service discovery.

Some of the topics to be covered include:

Service communication using gRPC, a fast and efficient binary protocol

Creating Kubernetes Deployment Files
Deploying, Managing and Scaling services using Kubernetes
Using Kubernetes Service Discovery with gRPC

Cloud Integrations, Data Architecture and MDM solutions for Enterprise Applications WorkShop

In Cloud Integrations and Data Architecture talk, we will examine secure, scalable integrations on Enterprise applications. Through various scenarios, we will explore designing and implementing intricate integration patterns on multiple platforms. We will review how to communicate the solution and design trade-offs to business and technical people.

We will explore the following topics:
– Design high-performing, secure, and reliable integrations with applications.
– Analyze existing as-is and future to-be integration models.
– Integration Architecture blueprint. Streaming patterns.
– MDM Tools (Master Data Management).
– Integration with cloud applications. Error handling.
– Effectively communicate architecture design to various stakeholders at many levels.
– Follow best Domain practices in integration.
– Data modeling/Database Design. Data Stewardship. Data Quality Skills (concerned with clean data). Data Governance. Large Data Volume Considerations. Data Migration best practices.
– Architect robust, scalable security mechanisms for interfaces.

This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects

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.

Designing Well Architected Framework Workshop - Deep Dive

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

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 & Hardening Java Web Applications

It seems like everyday there is a new headline about a security breach in a major company’s web application. These breaches cause companies to lose their credibility and cost them large sums of money. Security is everybody’s job and requires us to be proactive.

This hands-on workshop is designed to teach you how to identify, exploit (legally) and fix vulnerabilities in modern Java web applications. Using an existing web application, you will learn ways to scan and test for common vulnerabilities using common penetration testing tools. You will learn about OWASP Top 10 vulnerabilities such as hijacking, injection, cross-site scripting, cross-site forgery and more. You will learn best practices around logging, error handling, intrusion detection, authentication and authorization. You will also learn how to improve security in your applications using existing libraries, frameworks and techniques to patch and prevent vulnerabilities making your software safer.

Java Design Patterns Deep Dive

Since 1994, the original Gang of Four Design Patterns book, “Design Patterns: Elements of Reusable Object-Oriented Software” has helped developers recognize common patterns in development. The book was originally written in C++, but there have been books that translate the original design patterns into their preferred language. One feature of “The Gang of Four Design Patterns” that has particularly stuck with me has been testability for the most part. With the exception of singleton, all patterns are unit testable. Design Patterns are also our common developer language. When a developer says “Let's use the Decorator Pattern” we know what is meant.

What's new though is functional programming, so we will also discuss how these patterns change in our new modern functional programming world. For example, functional currying in place of the builder pattern, using an enum for a singleton and reconstructing the state pattern using sealed interfaces. We will cover so much more, and I think you will be really excited about this topic and putting it into practice on your own codebase.

Java Testing Workshop With JUnit 5 and Mockito

The fundamental testing libraries in Java have undergone complete redesigns in the past few years. JUnit 5 redesigns the most well-known tool in all of testing. The most popular mocking library, Mockito, has also been rebuilt. This workshop will introduce the new features, help you use them as intended, and discuss experimental ideas still 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. With the release of Mockito 3, the mocking library now requires functional features from Java 8 and takes advantage of them in interesting ways. This workshop helps you work with both libraries.

Kotlin Workshop

Learn the basic syntax and semantics for the Kotlin programming language. Kotlin is an alternative JVM language that provides null safety, static typing, and powerful IDE support. This workshop will give you the chance to code in Kotlin, highlighting its similarities and differences from Java, how to use functional programming skills, work with collections, access restful web services, and more.

This workshop will examine features of Kotlin at a greater depth than most tutorials. Coroutines – the most popular feature of the language – will also be covered, as well as higher order functions, reduction operations like reduce and fold, and lambdas with receivers. Those topics progress toward building DSLs and builders in Kotlin. Terms like “apply”, “let”, “use”, “also”, and “with” will be covered along with their typical use cases.

Details of the type system, including the Any, Unit, and Nothing classes, will be included. Examples will be provided on how to define extension functions, infix operators, and inlining functions for efficiency.

Kubernetes Koncepts - 1/2 Day Hands On Workshop

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

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

Modern Java Unit Testing and Mocking Workshop

I know what you are thinking. Another unit testing presentation/workshop? That is so early 2000s. But a lot has changed if you haven't been keeping up with the unit testing space recently. Frameworks such as Junit 5 and Mockito 3 have been updated significantly. New programming styles such as lamdas and reactive are becoming mainstream, changing how we test our code. We also have new frameworks for integration testing, such as Testcontainer.

Whether you're a unit testing veteran or a newbie, this hands-on workshop will give you the experience and confidence necessary to write unit tests today.

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.

Project Loom JumpStart

There is a new way of Threading on it's way to Java, and that means it is time to prepare. Project Loom will be introducing Java Virtual Threads which are small Threads meant to perform quick operations with the need of procuring long-running OS threads which can prove to be expensive. In this class we will learn how to use these threads, what does it mean in relationship with the rest of the Java API, what does it mean for third party libraries.

1. What is a Virtual Thread
2. Creating and Using a Virtual Thread
3. What will Loom's Virtual Threads do to Futures
4. What is a Fiber
5. What is a Continuation?
6. What is a Scheduler?
7. What is Unwind and Invoke? (UAI)
8. Perform Asynchronous Challenges using Project Loom
9. When will it be Released
10. How does it compare to other languages and projects?

Reactive Programming with RxJava

I like to call Reactive Programming as Functional Programming++. There is so much similarity between FP and Rx and yet there are some significant differences. In this hands on workshop we will dive into what Reactive Programming is, learn about the APIs and capabilities, using RxJava as a vehicle.

While the examples will use RxJava, the concepts are general enough that you can readily benefit from the content, like backpressure and error handling, even if you are using other reactive libraries.

Reactive Spring : Modernizing Code and Architecture in the Spring Ecosystem

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

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.

Refactoring to Modern JavaScript Workshop

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!

Spring MVC

Spring is still the leading open source framework in the Java world for building web apps and web services. This workshop will walk through creating both, with special emphasis on deployable restful web services. In addition to the basic code, the workshop will look at how Spring operates, including the proxy design pattern, interceptors, managing singletons, and more.

=== Spring MVC architecture

• Major concepts
• Processing HTTP requests and responses
• Configuration options
• Test support

=== Spring Boot Features

• Spring MVC autoconfiguration
• HTTP message converters
• JSON serializers
• Serving static content
• Using template engines

=== Special bean types

• Handler mappings
• View resolvers
• Filters and interceptors
• Exception resolvers
• Content negotiation and REST

=== Annotated controllers

• Request mapping
• Handler methods
• Model objects
• Data binding and validation

=== Functional endpoints

• Handler functions
• Router functions and beans
• Deployment options
• Alternative language features

\s+[Rr]eg(ular [Ee]xpression|ex[pe]?)s? for Mortals (Workshop)

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.