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.

Beyond Kubernetes - An overview of the most popular Kubernetes-based applications that you should know about now

What you will learn:

Kubernetes has won the war when it comes to running and managing containerized workloads. It is essentially the operating system for containers. But beyond Kubernetes itself, there are a large set of community applications and tools that can greatly extend its value and integrate directly with it.

In this full-day workshop, author, trainer, and DevOps leader Brent Laster will provide you with an introduction AND hands-on experience with these various applications and tools. You'll learn not only what they are and how they interact with Kubernetes but get to experience actually using them to accomplish a task.

We'll cover orchestration with Helm & Kustomize, service meshes with Istio, CI/CD pipelines with Tekton, GitOps with ArgoCD and, if time allows - creating and managing Custom Resources in Kubernetes with the Operator pattern.

The planned workshop outline follows (subject to change).

Class outline

Part 1: Introduction and brief refresher/level-set on core concepts in Kubernetes. Agenda for class and quick overview of technologies.

Part 2: What is Helm? Basic concepts and function. Helm charts.

Lab 1: Working with Helm - in this lab, we'll compare a Helm chart against standard Kubernetes manifests and then deploy the Helm chart into Kubernetes

Part 3: Using custom values and functions in Helm charts

Lab 2: Templating with Helm - in this lab, we'll see how to change hard-coded values into templates, override values, and upgrade releases through Helm

Part 4: What is Kustomize? Basic concepts and function. How does Kustomize differ from Helm?

Lab 3: Run a basic Kustomize example - in this lab, we'll see how to make a set of manifests usable with Kustomize to add additional changes without modifying the original files

Part 5: Working with variants, overlays, and bases to create different versions of K8s manifests

Lab 4 - Creating Variants - in this lab, we'll see how to create production and stage variants of our simple application

Part 6: Service mesh leveraging Istio - what is it? How does it work? When should you use it?

Lab 5: Working with Istio - in this lab, we'll look at Istio and see how we can leverage some of its functionality with the sidecar containerss to do traffic-shifting, fault injection and more.

Part 7: CD with Tekton - defining Tasks as building blocks. What is Tekton and what are the advantages and disadvantages of it?

Lab 6: Working with Tekton Tasks - in this lab, we'll see how to run and use a basic Tekton Task.

Part 8: CICD with Tekton Pipelines - explaining how tasks are combined in Pipelines and how those can be used for CD

Lab 7: Creating Tekton Pipelines - in this lab, we'll see how to create a Tekton Pipeline to orchestrate our tasks and run them together.

Part 9: What is GitOps? How and why is it used? Intro to ArgoCD.

Lab 8: Getting Started with Argo CD.

Part 10: How to manage Custom Resources in Kubernetes with Operators. What is a custom resource, a custom resource definition, a control loop, and an operator? When do you need/use custom resources and operators?

Lab 9: Kubernetes Operators - in this lab, we'll get to install and work with a simple Kubernetes operator.

Get in the Fast Lane: Measuring Web Performance

Are you losing revenue to performance? 53% of mobile site visits are abandoned if a page takes longer than 3 seconds to load. Pinterest reduced load times by 40% and saw a 15% increase in sign ups. Starbucks implemented a 2x faster time to interactive resulting in a 65% increase in rewards registrations. AliExpress reduced load by 36% and saw a 10.5% increase in orders.

Performance is important. Tooling can be hard. Do flame charts intimidate you? Come learn how to audit and fix common performance issues using Chrome DevTools, Lighthouse, PageSpeed Insights, and webpagetest.org.

During this hands-on, full-day workshop, you will learn how to:

• Optimize and familiarize yourself with your DevTools environment
• Understand which metrics matter
• Measure the performance of existing applications
• Diagnose and prioritize performance problems
• Implement performance fixes

We will profile real applications to both learn the tools of measurement as well as see real performance problems in action. By the end of this workshop, you will be familiar with the following performance concepts. Many will be covered in-depth with exercises, and others will be covered in an overview with resources to learn more.

• Latency and loading: HTTP2, code splitting, caching and service workers, resource and priority hints, progressive rendering and lazy loading, third party scripts
• Reducing code: tree shaking, responsible imports, performance budgets, differential serving
• Assets: responsive images, font loading, network client hints
• Buttery smooth UI: long-running JavaScript
• Perceived performance and UX

Prerequisites: To attend this workshop, you must already have a working understanding of JavaScript, HTML, CSS, git, and the command line, including installing npm packages and running npm scripts (or yarn). You must also have a basic understanding of Chrome DevTools, including inspecting an element and using the console. You do not need advanced mastery of DevTools as we will be learning about the Network and Performance tabs plus other tools during this session. A basic understanding of webpack would be very helpful, but the concepts can still be learned during this segment of the workshop.

Preparation: Please come with a laptop ready for development. You must have Chrome and Node (v 8+) installed.

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

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.

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

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.

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 content-negotiation and representation choices such as JSON or JSON-LD
• The emergence of metadata approaches to describing and using APIs such as OpenAPI and Hydra-CG
• Security considerations
• Client technologies
• API Management approaches

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.

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

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.

Architecting Cloud Native Applications

By now your organization has planted a flag in “the Cloud” and it up to you to figure out just what that means to your application portfolio. Should everything be a microservice? Wait, what is a microservices anyway? How do you deal with massively distributed applications? How can event storming fix the gap between your business problems and domain model?

In this workshop, you will take a kata from event storming through to an initial design stopping along the way to discuss:

• Cloud native culture
• Domain driven design
• The importance of paved roads
• Chaos engineering
• Production Hardened Services

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

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.

Introduction to GitHub Actions - How to easily automate and integrate with GitHub

What you will learn

In this half-day workshop, open-source author, trainer and DevOps director Brent Laster will provide a solid introduction to GitHub Actions. You’ll learn about the core parts and pieces that make up an action, as well as the types of functionality and features they provide. You’ll also see how to combine them in simple workflows to accomplish basic tasks as well as how they can fit into a CI/CD environment. And you’ll learn about how to create and self-host your own actions.

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

Draft course outline (subject to change)

Section 1: A quick intro to GitHub Actions

Content: In this section, we’ll cover the basics of GitHub actions – what are they and why would we use them? We’ll cover what “event driven” means and what events, jobs, actions, steps, runners and workflows are. And we’ll see how they all related to each other and work together. We’ll see how to create and store a GitHub action. Finally, we’ll look at how to create a simple action.

Lab 1: Creating a simple example – In this lab, we’ll get a quick start learning about GitHub Actions by creating a simple project that uses them.
We'll also see what a first run of a workflow with actions looks like. this lab, attendees will create and use a basic GitHub Action

Section 2: Taking actions further

Content: In this section, we’ll cover how to find GitHub actions that might be of interest. We’ll look at how to share and version actions. And we’ll see how to use additional features with actions.

Lab 2: Learning more about Actions – In this lab, we'll see how to get more information about Actions and how to update our workflow to use others. We'll also see how to add jobs and commit changes through the browser interface.

Section 3: Working with your own action

Content: For this section, we’ll look at how to create and then use your own custom action

Lab 3: Adding your own action - in this lab, we'll see how to create and use a custom GitHub Action

Section 4: Looking at action logs and getting details

Content: For this section, we’ll dive into the logs produced for GitHub actions to understand what's really happening on the runner systems and also look at how to add some simple markup to add a status badge on your project.

Lab 4: Exploring logs - in this lab, we'll take a closer look at the different options for getting information from logs.

Section 5: Getting debug info

Content: In this section, we’ll cover how to get debug information when running through actions and workflows.

Lab 5: Looking at debug info - in this lab, we'll look at some ways to get more debugging info from our workflows

Part 6: Working with advanced workflows

Content: In this section, we'll look at various examples of advanced workflows including chaining workflows, using conditionals, and working with REST APIs to drive other events in GitHub.

Lab 6: Chaining workflows, using conditionals, and working with REST APIs in workflows.

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 …

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

Metrics for Software-Architects

Software metrics can be used effectively to judge the maintainability and architectural quality of a code base. Even more importantly, they can be used as canaries in a coal mine to warn early about dangerous accumulations of architectural and technical debt.

First we will introduce some key metrics that every architect should know (e.g., average component dependency, propagation cost, structural debt index, and more). Then we talks about the journey to create a metric to measure maintainability and introduces a new metric maintainability level. This metric is promising because its value usually matches quite well the gut feeling of developers about the maintainability of their software systems. Also covered is the use of free and commercial tools to gather metrics and follow their trends in an automated way.

Micro-Services Networking Workshop

If there is one thing guaranteed to be part of the micro-services story, networking and service stand out. Network management in a highly orchestrated world of networks, subnets and overlays increases the challenge. Add the topic of security and traffic management and the picture can be overwhelming.

This session will cover solutions to day 2 operations of networking a micro-service based cluster leveraging Istio, Jaeger and Kiali. Labs of specific solutions and on the fly network management will part of the presentation covering the following:

• Mature installation of Istio prepared for Istio upgrades
• Istio injection techniques and management
• mTLS management service to service
• Network fault injection
• Network fault detection along with circuit-breakers
• Network tracing and header propagation needs
• Production traffic switch to new service (A/B Testing)
• Ingress Traffic management

You will need for the labs:

• kubernetes 1.18+ cluster
• git / github access
• docker
• kubectl client tools

Multi-Tenant NoSQL and NewSQL cloud-data design patterns Workshop

We are all familiar with the 3rd Normal form. Does that scale? What are the best practices for designing resilient, multi-tenant, performant databases? In this talk, we will explore the database evaluation process, where we will make choices on technology stacks based on requirements and analyzing the CAP theorem. We will discover different Consistency, Availability, and Partition Tolerance techniques, investigate No-SQL databases, and help new cloud deployments using the 3rd Platform.

Big data has characteristics in the new Cloud domain, which requires storing various data for different use-cases. We will explore the Document data store, Key-value, Columnar NoSQL, Graph NoSQL and NewSQL databases.
Next, we will look at how to do data modeling for NoSQL columnar databases to support highly available partition tolerant use-cases. We will discover different strategies to help multi-tenant requirements. In the end, we will look at how to choose the right database? We will also see what the future of Databases are comparing based on Consistency Models, Schema Models, Database Languages, and Database storage.

We will look at data quality patterns and issues and how to use MDM strategy to fix these issues. We will explore survivor ship records and how to validate if the data is correct in system. In the end we will also look at GDPR and PII data strategies.

We will be exploring following databases types:

• Key-value stores

• Wide column stores

• Document stores

• Time Series DBMS

• Graph DBMS

• Object oriented DBMS

• Search engines

• RDF stores

• Spatial DBMS

• Event Stores

• Content stores

A few of the technologies we will explore are

• Cassandra

• Amazon DynamoDB

• MongoDB, HBase

• REDIS, MemcacheDB,

• RDF / SPARQL

• Graph Databases, Neo4J

• CockroachDB

This talk is ideal for the following roles:

• Architects

• Technical Leads

• Programers

• Integration Architects

• Solution Architects

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.

Software Design By Practice

We all are familiar with SOLID and other software design principles and have explored many design patterns. There is no better way to get a deeper understanding than to practice the concepts. Furthermore, some of the principles and patterns manifest themselves in what appear to be rather unconventional ways when applied under a set of constraints and requirements.

In this hands-on intensive workshop, we will take some problems and device elegant lightweight design, in code, and discuss the tradeoffs. Come experience the evolution of ideas into code and take shape by way of incremental development.

TensorFlow.js : Machine Learning in the Browser and Beyond With JavaScript

The concept of doing machine learning in JavaScript in the browser seems ludicrous at first blush. The reality is, however, it makes all the sense in the world. The question is how to do so performantly.

We will introduce you to a variety of use cases of why this makes sense and how Google has managed to make it a reality through a combination of WebGL, WebAssembly, CUDA, and more.

We will cover:

• Motivations for this crazy idea in the first place
• How to achieve portable performance
• Building applications that reuse existing models
• Caching strategies for large models
• Training models in the browser
• Combining browser capabilities such as images and video with machine learning algorithms

Terraform-ing your Cloud

A large part of embracing DevOps involves embracing automation. Over the last decade we have seen the emergence of “as Code” — Build-as-Code, Configuration-as-Code and Infrastructure-as-Code. The benefits to utilizing such tools are huge! We can codify the state of the world around our applications, giving us the ability to treat everything that our code needs like we treat the code itself. Version control, release management, tagging, even rolling backs are now possible.

Terraform, an open-source tool from HashiCorp allows us to build, control and modify our infrastructure. Terraform exposes a Domain-specific language (DSL) that we can use to express what our infrastructure should look like. Terraform can work with all the major cloud providers, including Amazon AWS, Google GCP and Microsoft Azure.

We will be using AWS as our playground for this workshop

Agenda

• The place for, and benefits of “Everything as Code” alongside GitOps
• Terraform's architecture
• Terraform 101
• Introduction to HCL
• What are providers?
• Initializing terraform and providers
• Dive right in! Creating your first resource in AWS using Terraform
• Understanding references, dependencies
• apply-ing terraform
• Variables and the HCL type-system
• Using data and output in your terraform scripts
• Understanding how Terraform manages state
• Using S3 as a backend
• DRY with Terraform modules
• Collaboration using Terraform
• Terraform ecosystem, testing, and GitOps
• Closing arguments, final Q/A, discussion

Instructions

Please visit https://github.com/looselytyped/terraform-workshop/ for detailed instructions. They might seem a tad arduous but it's not as bad as it looks :)

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

TypeScript for the Win!

There is no question JavaScript has become one of the most popular and widely-used programming languages. Unfortunately popularity doesn't necessarily translate to easy-to-maintain or always appropriate. Large code bases become difficult to reason over due to JavaScript's dynamic nature and flexible development style.

As a result of their own internal struggles with large JavaScript projects, Microsoft tasked Anders Hejlsberg of Delphi and C# fame to design a solution to the problem. The result is an incredibly useful, fun and effective approach to improving JavaScript development without impacting how you deploy your projects.

TypeScript is a superset of JavaScript that brings static typing, modern JavaScript features that may not yet be supported in your environment and improved tooling and documentation. Surprisingly, the results are then transpiled down to whatever flavor of JavaScript you need for your runtime environment.

In this workshop, we will introduce to you:

• What TypeScript brings to the table and why you should care
• The new language features available
• Approaches to gradually adopt TypeScript in your project
• How runtime errors become compile time errors with types and static checking
• How your build processes do and don't change
• How to set up a more fun and productive (and hopefully less frustrating) development environment

Upgrade to Modern Java: 2024 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 six-month 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.