Four days of deep, practitioner-led technical sessions — agentic AI, architecture patterns, security, cloud, and the craft of being an architect. No fluff, no vendor pitches.
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.
Computer with git client installed to access the version control system which will have lab related material.
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 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.
Please register on ww.hello2morrow.com and download and install Sonargraph-Explorer. The license is free and you will need the tool if you want to actively want to join exercises. You can also bring one of your projects, if you want to analyze your own code. (Java, C#, C/C++ or Python). I will provide snapshots of some open source projects if you prefer to work with an example.
Download link for examples: https://www.dropbox.com/scl/fi/znp5m7x8giiqmkaxp6ktg/ArchConf.zip?rlkey=bifgjeqim939gv9w5noiaobvn&st=ziows6zg&dl=0
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/
AWS Account with free tier
Windows, Mac or Linux PC/laptop
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.
*Github Account
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.
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
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.
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
The web is arguably the single most impactful revolution in human history (to date). By agreeing on a simple set of standards, we have collectively unlocked all the world's information. Documents can be discovered, retrieved, published, and shared so easily we don't even think about it.
Data, on the other hand, is a different story. Our data remains stuck in the 1980s. Locked in silos, each with a different format, interface, and conventions that must be interpreted by a human, parsed, mapped, and converted. Data is at the heart of many problems we solve today, and we produce data exponentially faster than we can consume it.
Today I can request any document from any server on the web. I need to know nothing about the underlying technology the server uses, nothing about how the information is stored or retrieved, and consume it instantly. We've been evolving those same capabilities with data over the past 20 years and the standards, tools, and technologies are reaching critical mass. The linked data revolution is now one that you can no longer ignore. Join us to see what you've been missing.
Completely Rewritten for 2023
Although the Resource-Oriented Architecture is one of the oldest and most successful distributed architectures, it remains poorly understood and often completely overlooked today.
Much of the microservices architecture pattern is focused on taking applications apart although seemingly everyone has different ideas on how to put things back together again.
In this session, we will start with a summary of the resource-oriented architecture along with it's strengths and weaknesses. Michael will share hard-earned, real-world experience applying ROA concepts to complex microservice environments to successfully build an infinitely scalable, extensible, and understandable system.
Mob Programming is a style of programming in which the entire team sits together and
works on a single task at a time. Teams that have worked this way have found that
many of the problems that plague normal development just melted away, possibly because communication and learning increases. Teams also find that the quality of their code increases. They find their capacity to create increases. However, the best part of all this is that teams end up being happier and more cohesive.
In this session we introduce the core concepts of mob programming and then get handson mobbing on a coding kata.
Many developers around the world have jumped on the Microservices bandwagon. Several organizations, in the past and also in the present, have built around monolithic and also service oriented architectures. What separate, however, Microservices from those efforts at large? How does a Microservices based architecture influence the design of the software applications, what are the key design principles we should keep in mind, and how to leverage design goals like reuse and extensibility?
In this presentation we will revisit the design goals we often focus on in software development and how those evolve in the context of Microservices.
The vast majority of developers have experience creating monoliths. Whereas that experience is really good to have from the point of view of building monoliths, they may become a hindrance when creating microservices. There are a few things we have to do differently, we have to unlearn a few design principles, we have to adhere to a few different architectural goals, and yet carry forward some of the techniques that have worked well before.
In this presentation, we will focus on how to transition from building monoliths to creating microservices.
Many developers aspire to become architects. Some of us serve currently as architects while the rest of us may hope to become one some day. We all have worked with architects, some good, and some that could be better. What are the traits of a good architect? What are the skills and qualities we should pick to become a very good one?
Come to this presentation to learn about things that can make that journey to be a successful architect a pleasant one.
Awareness is the knowledge or perception of a situation or fact, which based on myriad of factors is an elusive attribute. Likely the most significant unasked for skill… perhaps because it's challenging to “measure” or verify. It is challenging to be aware of aware, or is evidence of it's adherence. This session will cover different levels of architectural awareness. How to surface awareness and how you might respond to different technical situations once you are aware.
Within this session we look holistically an engineering, architecture and the software development process. Discussing:
* Awareness of when process needs to change (original purpose of Agile)
* Awareness of architectural complexity
* Awareness of a shift in architectural needs
* Awareness of application portfolio and application categorization
* Awareness of metrics surfacing system challenges
* Awareness of system scale (and what scale means for your application)
* Awareness when architectural rules are changing
* Awareness of motivation for feature requests
* Awareness of solving the right problem
The focus of the session will be mindful (defined as focusing on one's awareness), commentating in sharing strategies for heightening awareness as an architect and engineer.
The organization has grown and one line of business has become 2 and then 10. Each line of business is driving technology choices based on their own needs. Who and how do you manage alignment of technology across the entire Enterprise… Enter Enterprise Architecture! We need to stand up a new part of the organization.
This session will define the role of architects and architectures. We will walk through a framework of starting an Enterprise Architecture practice. Discussions will include:
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
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
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:
You will need for the labs:
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:
You will need for the labs:
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:
You will need for the labs:
This session will be a deep dive into the machine learning & artificial intelligence services and associated MLOPS within AWS. This will include updates to existing services, Amazon Data Wrangler, Sagemaker Studio, Sagemaker Pipelines, Sagemaker Endpoints, and any new services added (Amazon is constantly evolving in this space). We will cover key concepts of each of the services, common use cases, and design patterns.
Come to this session if you want to get up to speed on the ML/AI services in AWS.
This session will be a deep dive into the machine learning & artificial intelligence services and associated MLOPS within AWS. This will include updates to existing services, Amazon Data Wrangler, Sagemaker Studio, Sagemaker Pipelines, Sagemaker Endpoints, and any new services added (Amazon is constantly evolving in this space). We will cover key concepts of each of the services, common use cases, and design patterns.
Come to this session if you want to get up to speed on the ML/AI services in AWS.
This session will take a look at how the pandemic has impacted the skills needed by software architects from ideation to product delivery. For many architects, it’s not the technology-related areas that give you problems, but people-related areas (some things never change). We will dive into both areas.
Come to this session if you want to learn some tricks and tips for how to raise your game as an architect.
This session will be a deep dive into the software architecture and ecosystem surrounding cryptocurrencies. This will include mining, staking, hardware and software wallets, ledgers, and exchanges. We will also take a look at several of the latest design patterns, features, and trends in this marketplace.
Come to this session if you want to get up to speed on cryptocurrencies, the underlying software architecture, and the surrounding ecosystem.
Design patterns are commonplace in OO programming. With the introduction of lambda expressions in languages like Java, one has to wonder about their influence on design patterns.
In this presentation, we will take up some of the common design patterns and rework them using lambda expressions. We will also explore some other patterns that are not so common but are quite useful ways to apply lambdas.
git client
Java 8 or newer
Your favorite IDE, IntelliJ IDEA community edition recommended
Design patterns are commonplace in OO programming. With the introduction of lambda expressions in languages like Java, one has to wonder about their influence on design patterns.
In this presentation, we will take up some of the common design patterns and rework them using lambda expressions. We will also explore some other patterns that are not so common but are quite useful ways to apply lambdas.
git client
Java 8 or newer
Your favorite IDE, IntelliJ IDEA community edition recommended
Integration, once a luxury, is now a necessity. Doing this well, however, continues to be elusive. Early attempts to build better distributed systems such as DCOM, CORBA, and SOAP were widely regarded as failures. Today the focus is on REST, RPC, and graphql style APIs.
Which is best? The goto answer for architects is, of course, “it depends.”
In this session, we look at the various API approaches, how they attempt to deal with the challenge of decoupling client from server, evolvability, extensibility, adaptability, composability.
The biggest challenge is that needs change over time, and APIs must necessarily evolve. Versioning is challenging, and breaking changes are inevitable. You'll leave this session with a highlevel understanding of these approach, their respective tradeoffs and ultimately how to align your API approach with your architectural and organizational goals.
The difference between a junior and a senior dev isn't coding skills. A developer's coding skills are just their ante; necessary to get into the game but, like an ante, they only get you into the game.
Everything that happens from that point on depends on what else you bring to the table.
In this session, we explore the key skills necessary to make an impact, be effective, and will ultimately pave the way to grow into senior/principal level developers and 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.
This session will introduce some key metrics that every architect should know and also looks into the current research regarding software architecture metrics. Since we have 90 minutes there will be some time for hands-on software assessments. If you'd like to follow along bring your laptop and install Sonargraph-Explorer from our website www.hello2morrow.com. (It's free and covers most of the metrics we will introduce) Bring a Java, C#, C/C++ or project and run the metrics on your own code. Or just download an open source project and learn how to use metrics to assess software and detect issues.
Cloud native applications are distributed to reap the benefits of resource scaling. Distributed computing is powerful but it also makes you think differently in designing applications. Atomic, modular, highly cohesive, and low coupled applications play nicely on these distributed systems. But it comes with costs.
We’ll look at architecture styles that adapt well to running in containers and on Kubernetes. Along the way, we’ll note the extra things your application should do to play nicely with distributed cloud native targets.
Distributed computing is hard. A significant challenge is typically when you want to get something done you have to call another service. Understanding how services are discovered and connected is fundamental to understanding Kubernetes' strengths.
We’ll walk through some networking concepts and hands-on examples of various techniques to understand simple to sophisticated traffic control and routing. Ingress and Istio will be demystified.
Java developers and specifically Spring enthusiasts, fear not, Spring-based containers on Kubernetes continue to improve!
Write once, run anywhere, the promise of the JVM (WORA). Package once, run anywhere, the promise of containers (PORA). Given these two postulates, isn't WORA and PORA the same goal with different technologies? Yes, it’s completely redundant, and wasteful on expensive cloud servers. GraalVM has given us a way to reduce this waste with significant CPU and memory advantages. This solution has arrived with Spring Native.
We’ll walk through a hands-on session to see how much Spring Native can save you.
Hopefully, your DevOps team is ensuring that your platform is healthy and its delivery system is frictionless with new updates continuously rolling out. How can you achieve an automated and reliable delivery pipeline? Fortunately, your pipelines can all be run on Kubernetes. One of the highest maturity model goals with pipelines is automated delivery models. Specifically Progressive Delivery.
We’ll look at delivery model techniques and how Kubernetes and meshes provide a framework to make deliveries successful.
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.
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
The power of Java's functional programming goes far beyond lambdas and the filter, map of the Stream API. In this presentation we will look at various data transformations and see how the functional APIs in the JDK can provide concise solutions for these.
We will start with the Stream's API and quickly dive into some newer functions and also the utilities of the Collectors. Along the way you will get a deeper understanding of some of the excellent functions that are hidden in plain sight.
There are multiple elements to Kubernetes where each component seems like a character in a book, pods, services, deployments, secrets, jobs, config maps, and more. In this presentation, we just focus on the security aspect of Kubernetes and the components involved. Particularly centered around RBAC and ServiceAccounts. What they are, what they do. We discuss etcd and secrets. We will also discuss other options for security in Kubernetes.
There are multiple elements to Kubernetes where each component seems like a character in a book, pods, services, deployments, secrets, jobs, config maps, and more. In this presentation, we just focus on the security aspect of Kubernetes and the components involved. Particularly centered around RBAC and ServiceAccounts. What they are, what they do. We discuss etcd and secrets. We will also discuss other options for security in Kubernetes.
Service Accounts
Secrets
Kubernetes API
Authentication
Authorization
RBAC
Roles and Cluster Roles
Real-world applications nowadays are designed using both art and science. What is the process of coming up with a solution which works, scales, and is resilient?
What is it challenging to design a system for disruptive technologies?
System design is unstructured, and there are many ways to solve problems.
Gaining experience in new applications and technologies
Best practices change with time. The best way ten years ago can quickly become an anti-pattern.
In this talk, we will explore step by step guide to approach System design using real-world applications.
Come prepared to design a system for following applications interactively.
We will gain more knowledge with collective experience and best practices.
UBER System Design
NETFLIX System Design
INSTAGRAM System Design
YELP System Design
TWITTER System Design
Search Engines
Auto Suggestions / Recommendations System Design
Fraud Detection System Design
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Real-world applications nowadays are designed using both art and science. What is the process of coming up with a solution which works, scales, and is resilient?
What is it challenging to design a system for disruptive technologies?
System design is unstructured, and there are many ways to solve problems.
Gaining experience in new applications and technologies
Best practices change with time. The best way ten years ago can quickly become an anti-pattern.
In this talk, we will explore step by step guide to approach System design using real-world applications.
Come prepared to design a system for following applications interactively.
We will gain more knowledge with collective experience and best practices.
UBER System Design
NETFLIX System Design
INSTAGRAM System Design
YELP System Design
TWITTER System Design
Search Engines
Auto Suggestions / Recommendations System Design
Fraud Detection System Design
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
We live in a world of microservices. Yet, what is a microservice? What defines the boundaries of a microservice? How do we define the relationships between microservices? Thankfully domain-driven design gives us the concepts and practices to better design and decompose our services.
In this session we will consider many of the concepts of DDD — How bounded contexts use Ubiquitous language to model the domain, how context maps can be used to establish the interconnections between services as well aggregates and domains events, all of which will service us well as we go about creating our microservices.
We will also discuss the “tactical” patterns of DDD — We will see how we can “embed” the ubiquitous language in code, and the architectural influences of DDD.
This workshop will have you thinking about how to think in DDD using DDD concepts and ideas. Using polls, and mini-exercises we attempt to better cement the ideas of DDD so we can start applying them at work.
We live in a world of microservices. Yet, what is a microservice? What defines the boundaries of a microservice? How do we define the relationships between microservices? Thankfully domain-driven design gives us the concepts and practices to better design and decompose our services.
In this session we will consider many of the concepts of DDD — How bounded contexts use Ubiquitous language to model the domain, how context maps can be used to establish the interconnections between services as well aggregates and domains events, all of which will service us well as we go about creating our microservices.
We will also discuss the “tactical” patterns of DDD — We will see how we can “embed” the ubiquitous language in code, and the architectural influences of DDD.
This workshop will have you thinking about how to think in DDD using DDD concepts and ideas. Using polls, and mini-exercises we attempt to better cement the ideas of DDD so we can start applying them at work.
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:
A GitHub Account
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:
A GitHub Account
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:
A GitHub Account
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:
A GitHub Account
In tech teams it's a constant firefight. We react. Then we react to the reaction… the cycle continues. In all this noise, in all this chaos, how do we move forward. How do we remain proactive?
A great leader must be an enabler for the team. At times this means insulating the team from the noise. At other times it means improving the environment for the team. At all times, however, it requires setting clear priorities and conditions for success.
This session is focused on the art of moving forward in even the noisiest environments.
Many of our apps allow users to upload files which then become available for some users to (re)download. Viruses and malware could tailgate these files into your system and infect your users! Join us to learn how to avoid this potential fatal mistake!
Malware and virus-based attacks are on the rise. We have all seen the news stories all around us. How do you easily prevent damage to your corporate reputation and potentially devistating damage to your users from such threats?
Join us for an in-depth discussion and exploration of an effective architecture which detects, isolates and prevents downloading of infected uploaded files. We will also discuss other practical limits you should place on file uploads to avoid performance and UX issues.
Zero Trust Security and Authentication is on most CISOs, CTOs and architects top 10 'must do' lists and for good cause! Everywhere you read about bad actors, phishing and ransomware attacks with ever increasing frequency. Join us to learn how to implement one of the safest, most hacker-proof means of authenticating your users available today: Hardware-based authenticators!
Hardware based authenticators include security keys as well as device-resident bio-authenticators such as TouchId and Windows Hello. In this presentation, we will explore these devices, how they are accessed, managed and used to provide virtually hacker-proof authentication in modern web applications. We will discuss the current industry standards and specs which govern these devices and their use including FIDO and WebAuthn.
Everywhere you look, security breeches, phishing attacks and ransomware attacks are in the news and should be in the forefront of every technical leader's top 10 concerns. An effective strategy to combat such attacks and vulnerabilities begins with a zero-trust inspired authentication strategy, application architecture and deployment infrastructure.
Join us for an in depth analysis of the current options and best practices around implementing zero-trust compliant, modern authentication architectures and systems.
Everywhere you look, security breeches, phishing attacks and ransomware attacks are in the news and should be in the forefront of every technical leader's top 10 concerns. An effective strategy to combat such attacks and vulnerabilities begins with a zero-trust inspired authentication strategy.
Join us for an in depth analysis of the current options and best practices around implementing zero-trust compliant, modern authentication, architectures and systems.
You built the app. You are ready to launch! But how do you proceed from there? You need to ensure that, once deployed, your app remains 'up', healthy, available and secure. For that, you are going to need some serious tools in your belt! Join us as we explore the tools and services you can use to complete your deployment stack and give you all of the monitoring and control that you need for a successful launch!
You built the app. You are ready to launch! But how do you proceed from there? You need to ensure that, once deployed, your app remains 'up', healthy, available and secure. For that, you are going to need some serious tools in your belt! Join us as we explore the tools and services you can use to complete your deployment stack and give you all of the monitoring and control that you need for a successful launch!
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
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
As a software architect, you're at the forefront of building scalable, secure, and resilient systems that drive innovation while safeguarding critical digital assets. This workshop is designed to equip you with actionable strategies, cutting-edge tools, and deep technical insights into embedding security into every phase of the software development lifecycle.
In this immersive, hands-on session, we will explore how to elevate your DevSecOps practices to meet the challenges of today’s evolving threat landscape while ensuring productivity and operational excellence.
What You'll Learn:
Why You Should Attend:
Who Should Attend:
This workshop is ideal for:
Join us for this transformative session to gain the skills and knowledge necessary to design secure, scalable, and resilient systems that protect your organization and enable innovation.
This session is a must-attend for architects aiming to design secure, scalable systems while staying ahead in the rapidly evolving security landscape.
Game of Life is an intriguing game. At first look it looks simple, but as you look closer, it appears to be quite complex. How can we implement this game with different constraints, what are the constraints? Is it possible to use functional programming for this, to honor immutability? You see, it is intriguing.
We will discuss the constraints, think about how we may be able to solve them, and along the way discover how functional programming can play a role. We will have a fully working program, using live coding, at the end of this session, to illustrate some nice ideas that will emerge from our discussions.
Threads are considered lightweight but that's quite relative and in some context it appears to be rather heavyweight. The blocking nature of threads makes it rather unsuitable for asynchronous programming. That's the reason Java is introducing Virtual Threads.
In this presentation we will discuss the deficiencies of the current Thread infrastructure and, using practical examples, see how the virtual threads provide a much better model for asynchronous programming.
Seven steps methodology for designing superior AI-Enabled Microservices
In most of the Monolithic applications business objects and data, model designs are already present. As part of moving to cloud, companies miss out of the use-cases the REST APIs need to support. Implementing cloud solutions on top of existing models may lead to performance issues with APIs and cause scalability issues. Clients need to rewrite code due to a new version of APIs.
In most of the Monolithic applications business objects and data, model designs are already present. As part of moving to cloud, companies miss out of the use-cases the REST APIs need to support. Implementing cloud solutions on top of existing models may lead to performance issues with APIs and cause scalability issues. Clients need to rewrite code due to a new version of APIs.
In this talk, we will explore ten steps methodology for designing superior Cloud Native RESTFul Microservices APIs. Firstly, define the business domain objects and how they relate to use cases. If the use-case is to support <500 ms response time and availability of 99.99%, design the application for Consistency, Availability, and Partition tolerant. Next, Create an ideal design which solves the use-cases, refer to the industry standard JSONs and designs from schema.org, iana.org, and microformats.org. Later, find the fail points in the process and go back to the first step to resolving the pain points: Go back to Define the problem. Question to ask is what can go wrong? When can it go wrong? Next, create a Facade pattern to connect to either the existing Monolithic App or create a new App to support the new cloud use-cases. Create API Gateway, so other companies can build software and create more offerings. Next, design common Layers for error handling, logs, and security. For API security, perform Threat Modeling to find security vulnerabilities and plan for mitigation of risks. Use generic authentication using SAML, OAuth, and JWT to support Authentication and Authorization. Next, create an API Versioning strategy so that the REST API can evolve with minimal client changes. Apply Cloud Native design patterns for Resiliency. In the end, test APIs using contract driven testing and PACT files.
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Seven steps methodology for designing superior AI-Enabled Microservices
In most of the Monolithic applications business objects and data, model designs are already present. As part of moving to cloud, companies miss out of the use-cases the REST APIs need to support. Implementing cloud solutions on top of existing models may lead to performance issues with APIs and cause scalability issues. Clients need to rewrite code due to a new version of APIs.
In most of the Monolithic applications business objects and data, model designs are already present. As part of moving to cloud, companies miss out of the use-cases the REST APIs need to support. Implementing cloud solutions on top of existing models may lead to performance issues with APIs and cause scalability issues. Clients need to rewrite code due to a new version of APIs.
In this talk, we will explore ten steps methodology for designing superior Cloud Native RESTFul Microservices APIs. Firstly, define the business domain objects and how they relate to use cases. If the use-case is to support <500 ms response time and availability of 99.99%, design the application for Consistency, Availability, and Partition tolerant. Next, Create an ideal design which solves the use-cases, refer to the industry standard JSONs and designs from schema.org, iana.org, and microformats.org. Later, find the fail points in the process and go back to the first step to resolving the pain points: Go back to Define the problem. Question to ask is what can go wrong? When can it go wrong? Next, create a Facade pattern to connect to either the existing Monolithic App or create a new App to support the new cloud use-cases. Create API Gateway, so other companies can build software and create more offerings. Next, design common Layers for error handling, logs, and security. For API security, perform Threat Modeling to find security vulnerabilities and plan for mitigation of risks. Use generic authentication using SAML, OAuth, and JWT to support Authentication and Authorization. Next, create an API Versioning strategy so that the REST API can evolve with minimal client changes. Apply Cloud Native design patterns for Resiliency. In the end, test APIs using contract driven testing and PACT files.
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
When architecting a critical system the Availability of CAP theorem becomes the most important element. Architecture measures availability in 9s with 99.99% equating less than 1 hour of unplanned downtime. This session will focus on what it takes to get there.
After establishing high availability expectations and measurements, this session will dive into what it takes to establish the highest scale possible. It includes a look at infrastructure needs with a separation between capacity and scale. A look a service discovery with pro and cons of service to service dependencies. We look at infrastructure necessary such as health checks and monitoring. The session will include a look at different layers of fault domains including cross region.
Securing a web application is an enormous task. In this talk, we will explore how to protect enterprise applications. Can we shift left and do continuous exploitation testing while the code is still in development?
We will explore different kinds of vulnerabilities and how to secure your applications properly. Security patterns need to be understood by first wearing a hacker's hat and then putting the hat as a defender. In this workshop, we will explore different security patterns and determine how to prevent attacks.
We will be using OWASP ZAP to exploit applications.
Metrics are essential to measuring success for DevOps. In this talk, we will explore different dimensions and measure the Metrics and apply quality gates for DevSecOps projects.
As part of our exploration, we will look at how businesses can connect DevOps with Business Metrics. Ultimately Business value is critical for survival for any business. Management needs to realize that keeping DevSecOps will help in the speed of development and track how well the company is doing.
Key takeaways for this workshop is:
Threat Modeling techniques using the Threat modeling tool
Reconnaissance to gather information, Google hacking database, Exploit Database
Scanning for vulnerabilities using OWASP ZAP
Exploitation with DOS attacks
Lead Time: The time from code written to entering production
Deployment Frequency: How often deploys happen
Mean-Time-To-Recover (MTTR): How quickly can teams restore service after production outages
Change Fail Rate: What percentage of deploys result in service impairment or an outage
What will benefit from this course?
Developers and Architects who want to shift left for Ethical Hacking
Some knowledge of Linux
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Securing a web application is an enormous task. In this talk, we will explore how to protect enterprise applications. Can we shift left and do continuous exploitation testing while the code is still in development?
We will explore different kinds of vulnerabilities and how to secure your applications properly. Security patterns need to be understood by first wearing a hacker's hat and then putting the hat as a defender. In this workshop, we will explore different security patterns and determine how to prevent attacks.
We will be using OWASP ZAP to exploit applications.
Metrics are essential to measuring success for DevOps. In this talk, we will explore different dimensions and measure the Metrics and apply quality gates for DevSecOps projects.
As part of our exploration, we will look at how businesses can connect DevOps with Business Metrics. Ultimately Business value is critical for survival for any business. Management needs to realize that keeping DevSecOps will help in the speed of development and track how well the company is doing.
Key takeaways for this workshop is:
Threat Modeling techniques using the Threat modeling tool
Reconnaissance to gather information, Google hacking database, Exploit Database
Scanning for vulnerabilities using OWASP ZAP
Exploitation with DOS attacks
Lead Time: The time from code written to entering production
Deployment Frequency: How often deploys happen
Mean-Time-To-Recover (MTTR): How quickly can teams restore service after production outages
Change Fail Rate: What percentage of deploys result in service impairment or an outage
What will benefit from this course?
Developers and Architects who want to shift left for Ethical Hacking
Some knowledge of Linux
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Hashicorp Vault stores encrypted secrets securely. You can store anything that you want into Vault including API keys, passwords, and certificates. Vault can also store dynamic secrets where it can negotiate with a cloud service on your behalf without direct interaction with your API keys. Hashicorp Vault is well thought out “bank” of information that handles storage, encryption, leasing, sealing.
In this presentation, we will discuss setup, securing content, creating automatic secrets for AWS, sealing, how to deploy into Kubernetes, and how to integrate with code.
One of the hardest activities and strategies of DevOps team or should we say production is how to transition from one version of an application to another version of an application with cascading consequences of service dependencies. There are a number of strategies for managing this concern. In this talk, we will outline a few of them along with required conditions of the underlying infrastructure to achieve it.
This session will demonstrate on a DC/OS platform how to create a continuous delivery solution which pushes builds into production leverage blue / green deployments. Following this we will switch on the fly from blue to green and vice versa. We will stretch this concept to it's extreme and demonstrate A/B testing in a production environment.
Distributed computing has surprising challenges. When targeting applications for Kubernetes your capabilities should meet its demands. If you can raise your team’s understanding of the cloud native maturity model, then it will increase your success with Kubernetes solutions.
I get it, we don’t always follow the best techniques and your team does not do everything perfectly. However, it would be sad if you did not lay out some plans to eventually raise your capability goals. We’ll examine some worthwhile goals and applicable techniques.
Don't fear entropy, embrace it.
When you move toward distributed computing the likelihood of failure proportionally increases. It's not your fault, it's simply physics. Once you start spreading your data and applications across more devices, then access to resources such as CPU, memory, and I/O have a higher rate of failure.
Embrace entropy with chaos experiments and increase your cloud native capability model. We’ll investigate some of the leading chaos frameworks for Kubernetes and dive into hands-on experiments targeted within blast radiuses.
We all have read good books that tell us to choose delegation over inheritance. Yet, we often choose inheritance? Why is that?
In this presentation we will discuss the reasons, from the OO design point of view when we should choose inheritance and when we should choose delegation. Then we will discuss why we tend to lean towards inheritance. We will then model a problems to use delegation, using Java (plus some libraries), Groovy, and Kotlin and achieve fluent implementations of delegation. We will conclude with good recommendations on when to choose which 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.
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
Albert Einstein once said — “We cannot solve our problems with the same thinking we used when we created them.”
As developers, architects, managers, tech-leads, our job entails solving big problems. However, our systems are composed of parts, and it is the interaction of those parts that ensure the system works, and tells us where to go looking when things fail. What does it mean to think in systems? What are the benefits, and what are tools are available to us? If any of this intrigues you (and it should) come join me as we explore a new way of thinking about problems, both big and small.
In this session we will take a page from Donella H. Meadows fantastic book “Thinking in Systems” and attempt to get an understanding of what makes up a system, how we can tease apart the moving parts of the system, and get into the mindset of a “systems thinker”.