It's not just architecture—it's evolutionary architecture. But to evolve your architecture, you need to measure it. And how does that work exactly? How does one measure something as abstract as architecture?
In this session we'll discuss various strategies for measuring your architecture. We'll see how you know if your software architecture is working for you, and how to know which metrics to keep an eye on. We'll also see the benefits of measuring your architecture.
We'll cover a range of topics in this session, including
Different kinds of metrics to measure your architecture
The benefits of measurements
Improving visibility into architecture metrics
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.
“Humans became behaviourally modern the moment they committed to storing abstract information outside their brains.” —Lyn Wadley
As architects, we often bridge the gaps that exist between all of the teams and stakeholders involved in the success or failure of a system. Because of this, information is hitting us from every direction. How we capture, organize, distill, and express this information is critical to our own success or failure.
Unfortunately, while excellent at abstract thinking, our brains are equally terrible at random recall. What we need is a second brain that excels at providing us with the right information at the right time. In this session, we're going to learn Digital Knowledge Management workflows and tools that will help us build and use that second brain.
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.
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:
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.
In today’s volatile technology and business climate, big architecture up front is not sustainable. Attempts to define the architectural vision for a system early in the development lifecycle does not work. To accept change, teams are moving to agile methods, but agile methods provide little architectural guidance. In this session, we provide practical guidance for software architecture on agile projects.
We will explore several principles that help us create more flexible and adaptable software systems.We’ll expose the true essence of what’s meant when we say “architectural agility.” And we’ll explore the real goal of software architecture and how we can accommodate architectural change to help increase architectural agility.
The architecture paradigms we’re using are changing. The platforms we deploy our software to are changing. We are confronted with several new architecture paradigms to choose from, such as microservices and miniservices. Should we automatically discard some of the proven architectures we’ve used in the past, including more traditional web services? Likewise, new platforms, such as cloud, complicate the decision. Yet, at the heart of this transformation is modularity. From monoliths to microservices and everything in between, modularity is the foundation.
In this session, we’ll explore how modularity is impacting the platforms we are leveraging and the architecture paradigms we’ll use and offer a clear roadmap with proven guidance on navigating the architecture decisions we must make.
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.
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 - 10 minutes
Availability patterns - 10 minutes
Recovery Point Objective and Recovery Time Objectives
Data backup data patterns
Routing Strategies - 10 minutes
Service quotas and constraints - 5 minutes
Design your workload service architecture - 5 minutes
Failure management in a distributed system
Monitoring workload resources
Calculating the response times
Fallacies of Distributed Systems
Testing reliability
Hands-on Exercises / Case Studies
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.
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 - 10 minutes
Availability patterns - 10 minutes
Recovery Point Objective and Recovery Time Objectives
Data backup data patterns
Routing Strategies - 10 minutes
Service quotas and constraints - 5 minutes
Design your workload service architecture - 5 minutes
Failure management in a distributed system
Monitoring workload resources
Calculating the response times
Fallacies of Distributed Systems
Testing reliability
Hands-on Exercises / Case Studies
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
Resilient architecture is fundamental when working in distributed, cloud-based systems. Designing and architecting large-scale applications managing millions of requests brings unique challenges with availability, performance, and integration. You will need to make difficult choices and evaluate tradeoffs. Luckily, you can use different architecture patterns to make a distributed application more resilient. Based on evolutionary architecture, this approach enables you to create systems designed to evolve with the ever-changing software development ecosystem. Resilient architecture patterns will allow you to create systems that continue functioning even when components fail.
Join expert Rohit Bhardwaj to learn how to implement an evolutionary architecture approach and understand resilient architecture patterns. This training will explore architecture decisions you may need to make when evaluating your architecture to improve performance and resiliency. For example, you will no longer struggle to handle millions of requests per second or face issues when routing traffic.
What you'll learn — and how you can apply it
By the end of this live, hands-on, online course, you'll understand the following:
How to create responsive, maintainable, extensible architecture from resilient, elastic design utilizing message-driven services
How to design cost-effective Recovery Point Objectives (RPOs) and Recovery Time Objectives (RTOs)
How to identify blocking issues with microservices in the cloud
How to evaluate caching strategies that can help lower costs and protect from DOS attacks
And you'll be able to:
Design high availability, high scalability, low latency, and resilient architectures.
Analyze and review implementations.
Identify key scalability challenges in your company.
Prevent cascading failures and preserve functionality.
This training is for you because…
You have an existing need to evaluate your current architecture.
You want to understand best practices.
You need to design new systems and want to evaluate which pattern to use.
Prerequisites
Basic knowledge of software architecture
Familiarity with design principles
Thinking application as stateless for all the API calls makes the system available most of the time and requires creating a cache for common distributed data. Next, we examine how to deal with cascading failures and timeout scenarios. As part of auto-healing, applications need to Detect, Prevent, Recover, Mitigate, and Complement so that the service is resilient.
The key takeaways for the audience are as follows:
*Resiliency is essential for any feature in the cloud.
*Understanding the value chain is critical to identifying failure points.
*Challenges come in determining if there is a failure and designing the system for auto-
healing
*The focus should be first to prevent a failure from occurring.
*Identifying critical challenges in your company and tools and techniques to auto-heal and provide a sustainable solution
Course Schedule
Evolutionary Architecture:
– Scaling to 100 million customers
– Understanding Requirements - Empathy Map
– Fail Points
– Defining KPIs
Resilient Patterns:
– BulkHead pattern
– Routing Strategies
– Design Issues with Microservices
– API Gateway Pattern
– Database per Service Pattern
– Database Sharding Patterns
– Fan out Pattern
– Publish-Subscribe Pattern
– Command Query Responsibility Segregation (CQRS)
– Message filter pattern
– Topic-queue-chaining Pattern
– Message Partitioning Patterns
– Priority Queue Pattern
Caching:
– Caching and Failure Injection
– Distributed system challenges
– Caching Patterns
– Order in Chaos
– Resilient Steps
– Resources
Resilient architecture is fundamental when working in distributed, cloud-based systems. Designing and architecting large-scale applications managing millions of requests brings unique challenges with availability, performance, and integration. You will need to make difficult choices and evaluate tradeoffs. Luckily, you can use different architecture patterns to make a distributed application more resilient. Based on evolutionary architecture, this approach enables you to create systems designed to evolve with the ever-changing software development ecosystem. Resilient architecture patterns will allow you to create systems that continue functioning even when components fail.
Join expert Rohit Bhardwaj to learn how to implement an evolutionary architecture approach and understand resilient architecture patterns. This training will explore architecture decisions you may need to make when evaluating your architecture to improve performance and resiliency. For example, you will no longer struggle to handle millions of requests per second or face issues when routing traffic.
What you'll learn — and how you can apply it
By the end of this live, hands-on, online course, you'll understand the following:
How to create responsive, maintainable, extensible architecture from resilient, elastic design utilizing message-driven services
How to design cost-effective Recovery Point Objectives (RPOs) and Recovery Time Objectives (RTOs)
How to identify blocking issues with microservices in the cloud
How to evaluate caching strategies that can help lower costs and protect from DOS attacks
And you'll be able to:
Design high availability, high scalability, low latency, and resilient architectures.
Analyze and review implementations.
Identify key scalability challenges in your company.
Prevent cascading failures and preserve functionality.
This training is for you because…
You have an existing need to evaluate your current architecture.
You want to understand best practices.
You need to design new systems and want to evaluate which pattern to use.
Prerequisites
Basic knowledge of software architecture
Familiarity with design principles
Thinking application as stateless for all the API calls makes the system available most of the time and requires creating a cache for common distributed data. Next, we examine how to deal with cascading failures and timeout scenarios. As part of auto-healing, applications need to Detect, Prevent, Recover, Mitigate, and Complement so that the service is resilient.
The key takeaways for the audience are as follows:
*Resiliency is essential for any feature in the cloud.
*Understanding the value chain is critical to identifying failure points.
*Challenges come in determining if there is a failure and designing the system for auto-
healing
*The focus should be first to prevent a failure from occurring.
*Identifying critical challenges in your company and tools and techniques to auto-heal and provide a sustainable solution
Course Schedule
Evolutionary Architecture:
– Scaling to 100 million customers
– Understanding Requirements - Empathy Map
– Fail Points
– Defining KPIs
Resilient Patterns:
– BulkHead pattern
– Routing Strategies
– Design Issues with Microservices
– API Gateway Pattern
– Database per Service Pattern
– Database Sharding Patterns
– Fan out Pattern
– Publish-Subscribe Pattern
– Command Query Responsibility Segregation (CQRS)
– Message filter pattern
– Topic-queue-chaining Pattern
– Message Partitioning Patterns
– Priority Queue Pattern
Caching:
– Caching and Failure Injection
– Distributed system challenges
– Caching Patterns
– Order in Chaos
– Resilient Steps
– Resources
There are many architectural patterns, from monoliths to distributed architectures. It can be daunting to choose between them.
In this workshop we will discuss approaches we can take to evaluating which architectural pattern may apply to different applications, what those patterns are, and a method to arriving at the most suitable pattern that may be appropriate for different applications.
There are many architectural patterns, from monoliths to distributed architectures. It can be daunting to choose between them.
In this workshop we will discuss approaches we can take to evaluating which architectural pattern may apply to different applications, what those patterns are, and a method to arriving at the most suitable pattern that may be appropriate for different applications.
Modern HTTP APIs power today’s connected world, acting as the core interface not only for developers, but also for the ever-growing ecosystem of machines, services, and now AI agents. As every organization is increasingly expected to produce and consume APIs at scale, the ability to design, build, deploy, and operate consistent, high-quality APIs has become a key competitive differentiator. With AI accelerating the need for composable, well-structured, and discoverable interfaces, API maturity is no longer optional—it’s essential. However, building and scaling effective API Design First practices across an enterprise is still fraught with manual processes, inconsistent standards, and slow governance models. To succeed, organizations must reimagine API Governance as a strategic enabler—one that prioritizes collaboration, stewardship, and automation.
In this session, we’ll explore the core stages of the API design lifecycle and share how to implement practical, modern governance models that increase productivity without sacrificing control. Drawing on real-world examples from SPS Commerce, as well as off-the-shelf tooling and custom solutions, we’ll show how to align your teams, accelerate delivery, and produce APIs that are robust, reusable, and ready for both human and AI consumers.
A lot of development teams have built out fully automated CI/CD pipelines to deliver code to production fast! Then you quickly discover that the new bottleneck in delivering features is their existence in longlived feature branches and no true CI is actually happening. This problem compounds as you start spinning up microservices and building features across your multirepo architecture and coordinating some ultrafancy release schedule so it all deploys together. Feature flags provide you the mechanism to reclaim control of the release of your features and get back to shortlived branches with true CI. However, what you're not told about feature flags in those simple “if/else” getting started demos is that there is an upfront cost to your development time, additional complexities, and some pitfalls to be careful of as you begin expanding feature flag usage to the organization. If you know how to navigate these complexities you will start to unleash true velocity across your teams.
In this talk, we'll get started with some of the feature flagging basics before quickly moving into some practical feature flagging examples that demonstrate its usage beyond the basic scenarios as we talk about UI, API, operations, migrations, and experimentation. We will explore some of the hard questions around “architecting feature flags” for your organization.
Sharing code and internal libraries across your distributed microservice ecosystem feels like a recipe for disaster! After all, you have always been told and likely witnessed how this type of coupling can add a lot of friction to a world that is built for high velocity. But I'm also willing to bet you have experienced the opposite side effects of dealing with dozens of services that have had the same chunks of code copied and pasted over and over again, and now you need to make a standardized, simple header change to all services across your platform; talk about tedious, frictional, errorprone work that you probably will not do! Using a variety of codesharing processes and techniques like inner sourcing, module design, automated updates, and service templates, reusing code in your organization can be built as an asset rather than a liability.
In this talk, we will explore the architectural myth in microservices that you should NEVER share any code and explore the dos and don'ts of the types of reuse that you want to achieve through appropriate coupling. We will examine effective reuse patterns, including what a Service Template architecture looks like, while also spending time on the lifecycle of shared code and practically rolling it out to your services. We will finish it off with some considerations and struggles you are likely to run into introducing code reuse patterns into the enterprise.
Azure DevOps Pipelines is one of the most popular CI/CD tools for software development with cloud-based deployments. It is a mature platform with over 15 years of experience that is continuing to evolve with many productivity benefits for the Enterprise. By harnessing the extension points of Azure Pipelines you can take an already great cloud-based platform and mold it into an incredible developer experience that significantly enhances developer productivity and streamlines the adoption of best practices in your organization.
In this session, we will start by exploring the history and capabilities of Azure Pipelines. We will dive into the most effective ways you can supercharge your pipelines by applying reuse, governance, and best practices throughout the enterprise. We will see how dramatically the productivity of an organization can be impacted through an Azure Pipelines real-world use-case.
How does designing microservices differ from designing more traditional applications? What is a better way to learn than to take a problem, analyzing the requirements, exploring the design options, applying the concepts of bounded context, and arrive at the architecture and design of Microservices to realize the requirements?
Come to this session to get a practical, hands-on practice to navigate from requirements all the way to a workable solution and along the way learn about different architectural goals and approaches that can help with design.
Most mainstream languages started out with support for multithreading. Threads were considered lightweight but that term is relative. Threads were not ideal from the point of view of resource utilization and they often lead to higher cost of deployment. There has been a greater emphasis on asynchronous programming in recent times, due to the nature of applications and the architectural patterns they tend to favor.
In this presentation we will discuss how this shift is transforming both the programming languages, the ecosystems, and how we develop applications.
Why talk about resilience when thinking of scale? It turns out all the effort we put in to achieve great performance may be lost if we are not careful with failures. Failure is not only about unavailability of parts of an application to some users, it may result in overall poor performance for everyone else as well.
In this presentation we will discuss ways to attain scale and discuss how to preserve those efforts by dealing with failures properly.
Over the years we have learned and applied several software design principles. Many of these principles have been very useful and have served as guiding principles and, at times, as guard rails to develop better software. However, the principles do not work in isolation. They interplay with each other and sometimes even against each other.
In this presentation we will look at the trade offs in applying well known design principles within the confines of the architectures that applications may be based on.
Big up front design is discouraged in agile development. However, we know that architecture plays a significant part in software systems. Evolving architecture during the development of an application seems to be a risky business.
In this presentation we will discuss the reasons to evolve the architecture, some of the core principles that can help us develop in such a manner, and the ways to minimize the risk and succeed in creating a practical and useful architecture.
Embraced containers yet? If so, that only presents the beginning of the journey. Designing your images to be lean, and your containers configurable requires us to leverage Dockerfiles to their maximum potential. At scale, everything matters—build times, testing, multi-stage builds, conventions around tagging and logging. There is a whole ecosystem of tools around how we can best build our images and containers.
In this session we will learn many a trick on how we can leverage Docker's own tooling as well as third-party tools to ensure that our first steps in the container world are the right ones.
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:
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
Have you ever stopped to think about how to build a database? The thing is, there isn't just one way, as we can see by the massive number of data infrastructure options we have to choose from. It's a nonstop series of tradeoffs, each motivated by the constraints the database wants to satisfy. An in-memory transactional database would be one thing. A general-purpose, single-server relational database would be another. A low-latency, horizontally scalable analytics database would be…the journey we're going to take.
In this talk, we'll start by picking a data model, make decisions about serialization and storage, choose indexing strategies, pick a query language, and figure out how to scale, eventually ending up with something that looks remarkably like Apache Pinot, a real-time analytics database. Pinot was built on a journey like this, always optimized for ultra low-latency, user-facing analytics at scale. In the real world, Pinot is used by applications like LinkedIn and UberEats to expose the state of the system not just to internal decision-makers, but to the users of the system itself, including all of us people who consumers of analytical queries. By focusing on the internals of Pinot and the tradeoffs made along the way to build a database of its kind, we'll see how it enables a new class of applications that every user of a system into a decision maker.
Event-driven architectures are not new, but they are newly ascendant. For the first time since the client-server revolution of 40 years ago, a new architectural paradigm is changing the way we build systems. Apache Kafka and microservices are at the center of this movement.
In this workshop, we’ll discuss the issues that arise turning a monolith into a set of reactive services, including issues like data contracts, integrating with the systems you can't change, handling request-response interfaces, and more. We'll also discuss common infrastructure choices like Apache Flink and Apache Pinot. Hands-on exercises will focus on understanding your organization's data and forming a plan to refactor that monolith that seems like it will never go away.
I'm looking forward to having you in the Event-Driven Architecture Workshop! To get the best use of our time together, the in-person exercises will focus on understanding the systems you're currently using at work and planning their refactoring to microservices. You should bring a laptop, a pen, and energy for the day!
When things get a little bit cheaper, we buy a little bit more of them. When things get cheaper by several orders of magnitude, you don't just see changes in the margins, but fundamental transformations in entire ecosystems. Apache Pinot is a driver of this kind of transformation in the world of real-time analytics.
Pinot is a real-time, distributed, user-facing analytics database. The rich set of indexing strategies makes it a perfect fit for running highly concurrent queries on multi-dimensional data, often with millisecond latency. It has out-of-the box integration with Apache Kafka, S3, Presto, HDFS, and more. And it's so much faster on typical analytics workloads that it is not just a marginally better data warehouse, but the cornerstone of the next revolution in analytics: systems that expose data not just to internal decision makers, but to customers using the system itself. Pinot helps expand the definition of a “decision-maker” not just down the org chart, but out of the organization to everyone who uses the system.
In this talk, you'll learn how Pinot is put together and why it performs the way it does. You'll leave knowing its architecture, how to query it, and why it's a critical infrastructure component in the modern data stack. This is a technology you're likely to need soon, so come to this talk for a jumpstart.
Alistair Cockburn has described software development as a game in which we choose among three moves: invent, decide, and communicate. Most of our time at No Fluff is spent learning how to be better at inventing. Beyond that, we understand the importance of good communication, and take steps to improve in that capacity. Rarely, however, do we acknowledge the role of decision making in the life of software teams, what can cause it to go wrong, and how to improve it.
In this talk, we will explore decision making pathologies and their remedies in individual, team, and organizational dimensions. We'll consider how our own cognitive limitations can lead us to to make bad decisions as individuals, and what we might do to compensate for those personal weaknesses. We'll learn how a team can fall into decisionmaking dysfunction, and what techniques a leader might employ to healthy functioning to an afflicted group. We'll also look at how organizational structure and culture can discourage quality decision making, and what leaders to swim against the tide.
Software teams spend a great deal of time making decisions that place enormous amounts of capital on the line. Team members and leaders owe it to themselves to learn how to make them well.
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.
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.
As we migrate towards distributed applications, it is more than just our architectures that are changing, so too are the structures of our teams. The Inverse Conway Maneuver tells us small, autonomous teams are needed to produce small, autonomous services. Architects are spread thin and can’t be involved with every decision. Today, we must empower our teams but we need to ensure our teams are making good choices. How do we do that? How do you put together a cohesive architecture around distributed teams?
This talk will discuss creating “paved roads”, well worn paths that we know works and we can support. We will also explore the importance of fitness functions to help our teams adopt appropriate designs.
Functional programming has been around for a long time, but in recent years almost all mainstream languages have eagerly embraced it. Developers are no longer thinking it it is a good idea, but are building systems with the constructs of functional programming. In reality, we are building systems with hybrid models, imperative, object-oriented, and functional paradigms.
In this presentation we will take a quick look at the main benefits and capabilities of functional programming, some of the requirements, and how we can design systems in a way we can practically honor those requirements in order to reap the benefits of the paradigm. We will draw inspirations from practical applications and libraries that illustrate how to design and architect using the functional approach.
We have measures for health of a person, a process plant, an aircraft, etc. How do we measure the health of your applications, from the architecture point of view. Fitness functions are intended to provide a health status and can be useful to keep an eye on the system as the architecture evolves.
In this presentation we will look at fitness functions, the different types, present examples, and discuss how they may apply to your own applications.
Design Patterns are common ways to solve problems that developers have discovered over time. They often fill the gaps between the language capabilities and the design goals. When languages mature, sometimes patterns become natural features of languages and blend in to the natural way of writing code instead of a special effort. Java has evolved significantly over the years.
In this session we will revisit some common design problems and see how patterns are realized to solve those problems with the modern capabilities in Java.
Architecture is a tool of structure and facilitation. It is a set of practices designed to elicit a capacity to absorb change. The Web is one of the most successful architectures ever built and most developers still have only a weak grasp on its implications. In the new world of mass technical layoffs, it will be more important than ever for developers, technologists, and architects to do more with less. It will be crucial to demonstrate a capacity to embrace change, not fear it.
In this workshop, we will connect the architecture of the Internet to the Web to API strategies to Linked Data and finally to Knowledge Graphs as a facilitating set of choices and practices to allow our information to embrace technical and business change. We can capture value for longer.
The Internet works as it was designed. Occasionally new uses, new technologies, and new scenarios confound those designs and force us to evolve. Fortunately, the architecture allows this quite easily, but where and how to effect change is not always obvious.
For those who wish “Full Stack Engineering” to be a more accurate view of their background than simply developing front AND back end systems, this talk will be a comprehensive and illuminating discussion about how the designs of the 1960s have evolved as an architecture and updated collection of protocols and standards.
The locus of computation is no longer relegated to the quaint notion of a CPU running on a computer. Our modern business mandates require us to embrace a menagerie of computational elements involving CPUs, systems on chips (SOCs), GPUs, FPGAs, ASICs and more. Avoiding a feature-tested explosion of complexity in our applications is crucial to successful delivery strategies that embrace all of these elements and locations. There are waves of change crashing into our industry involving explosions of data, an end to the non-linear trends of Moore’s Law-based speed ups, and a realization that computation costs time, money, power, and more.
At the intersection of architecture, hardware evolution, and more stable software is a fascinating set of technologies that will help lay the foundation for 21st Century software systems.
Decentralization and Content-based addressing represent a significant advancement in the development of stable, scalable, censorship-resistant systems. They require a remarkable amount of architectural thinking to work effectively. The Interplanetary File System (IPFS) is an umbrella project covering a cornucopia of extremely well designed layers that will prop up and extend the Web in many new directions. Come here about a future that looks a little bit like combining the Web with Git, Bittorrent, Self-certifying file systems, Distributed Hash Tables and more.
We will discuss the architectural layers of this approach and what each brings to the table.
Machine Learning is clearly here to stay. While it is a far cry from actual Artificial Intelligence, it provides many invaluable and remarkable ways to learn from the data we are collecting about our customers, products and daily activities. The past afforded us machine learning libraries which became machine learning frameworks. Now, we are designing and building machine learning platforms that facilitate entire initiatives in reusable and extensible ways.
We will discuss many of the drivers of modern machine learning systems and the architectures that we are seeing emerge as well as the security implications of protecting them.
Machine Learning is clearly here to stay. While it is a far cry from actual Artificial Intelligence, it provides many invaluable and remarkable ways to learn from the data we are collecting about our customers, products and daily activities. The past afforded us machine learning libraries which became machine learning frameworks. Now, we are designing and building machine learning platforms that facilitate entire initiatives in reusable and extensible ways.
We will discuss many of the drivers of modern machine learning systems and the architectures that we are seeing emerge as well as the security implications of protecting them.
Business requirements are not the only influencers of our technical solutions. Laws and Regulations transform the technical landscape in ways that require us to redefine our architecture, as well as our skill-set. This is especially true with Data Privacy. Since GDPR and CCPA, our industry is witnessing a new career path emerge: the Privacy Engineer. Where security started 10 years ago, so does privacy engineering. Join us as we look at Privacy by Design (PbD) and introduce some architecture patterns that align with privacy strategies.
Agenda:
Should Information Management systems apply the services architecture? Many data provisioning and BI systems are monolithic, tightly coupled, difficult to scale, and stumble when it comes to delivering MVP in a timely manner.
In this session we will look at the common obstacles such systems inherently bring with them, and how the Data as a Service architecture pattern addresses many of these issues.
Agenda
Privacy by Design is rapidly becoming the new focus for go forward architecture and application design. However, few companies have the luxury of building out new solutions and are struggling with ways to adapt their current systems to meet Privacy by Design criteria. If you find yourself in such a situation, know that you're not alone.
In this session we'll review some common legacy designs and provided suggestions for them that you can implement to better align your systems toward privacy strategies.
Agenda
With globally distributed applications (and teams!) the job of software architect isn’t getting any easier; applications are growing increasingly complex and architects are spread thin. You can’t be involved with every decision, you must empower your teams while ensuring they are making good choices. How do you do that? How can frameworks like Spring not only make your life easier but help your teams deliver robust applications to production? Spring Cloud has a veritable plethora of sub projects from circuit breakers to functions simplifying the task of building cloud native applications while making it easy for developers to adhere to best practices. At the same time it can be overwhelming to get your head wrapped around all the features Spring offers. This talk will show how Spring allows architects to focus on the critical design decisions they need to make while ensuring developers are empowered to implement critical business use cases. Today’s cloud native applications have similar pitfalls, luckily Spring is here to help you resolve them!
This talk will show how Spring allows architects to focus on the critical design decisions they need to make while ensuring developers are empowered to implement critical business use cases. Today’s cloud native applications have similar pitfalls, luckily Spring is here to help you resolve them!
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:
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:
By now I bet your company has hundreds, maybe thousands of services, heck you might even consider some of them micro is stature! And while many organizations have plowed headlong down this particular architectural path, your spidey sense might be tingling…how do we keep this ecosystem healthy?
In this talk, I will go beyond the buzzwords into the nitty gritty of actually succeeding with a service based architecture. We will cover the principles and practices that will make sure your systems are stable and resilient while allowing you to get a decent night's sleep!
Knowledge graphs have been quietly powering the future, unlocking new capabilities that were unimaginable to most just a few years ago. The few, however, have been imagining this future for decades and we've finally arrived at, what industry analysts are calling, “The year of the knowledge graph”
This session provides a historical look at the roots of Knowledge Graphs and how the ideas have evolved over the decades along with breakthroughs in various fields, have brought us to the brink of a new era in technology. Join us to see how far we've come and what is possible next!
In 2020, 61% of businesses migrated their workload to the cloud. Many of us were part of (or have been part of) such migrations. Unfortunately, most of these migration were performed without first building a substructure. Such a pitfall is now coming back to haunt us and proving difficult to resolve.
So what are some of those designs used in the substructure, and how can they be implemented as frameworks in an ephemeral environment?
Join us as we explore the patterns and show how they can be implemented using AWS services.
Agenda
Containers are everywhere. Of course, a large part of the appeal of containers is the ease with which you can get started. However, productionizing containers is a wholly different beast. From orchestration to scheduling, containers offer significantly different challenges than VMs.
In particular, in terms of security. Securing and hardening VMs is very different than that for containers.
In this twopart session, we will see what securing containers involves.
We'll be covering a wide range of topics, including
Understanding Cgroups and namespaces
What it takes to create your own container technology as a basis of understanding how containers really work
Securing the build and runtime
Secrets management
Shifting left with security in mind
Containers are everywhere. Of course, a large part of the appeal of containers is the ease with which you can get started. However, productionizing containers is a wholly different beast. From orchestration to scheduling, containers offer significantly different challenges than VMs.
In particular, in terms of security. Securing and hardening VMs is very different than that for containers.
In this twopart session, we will see what securing containers involves.
We'll be covering a wide range of topics, including
Understanding Cgroups and namespaces
What it takes to create your own container technology as a basis of understanding how containers really work
Securing the build and runtime
Secrets management
Shifting left with security in mind
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
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
No single architectural style solves all needs. Though microservices have taken the developer community by storm recently, they are not always the optimal solution. In some cases, a more monolithic architecture may be more suitable short term. Fortunately, proven architectural practices allow you to build software that transcends specific architectural alternatives and develop a software system that gives the development team the agility to shift between different architectural styles without undergoing a time-consuming, costly, and resource intensive refactoring effort. Modularity is the cornerstone of these alternatives.
In this workshop, we will examine the benefits and drawbacks of several different modular architecture alternatives and we’ll explore the infrastructure, skills, and practices necessary to build software with each of these alternatives. There will be straightforward exercises and demonstrations that show the alternatives and how to create software that provides the architectural agility to easily shift between architectural alternatives.
Software development is an amazing profession, requiring the delicate combination of analytical and creative skills. Understanding architectural patterns, agile best practices, and exploring the depths of platforms, tool, and languages requires deep analytical skills. Yet crafting a system also requires vision and understanding when to deviate from traditional best practices.
In this session, we will explore lessons learned over many years of building large software systems. We will challenge traditional assumptions and explore new ways of thinking.
Monoliths are out and microservices are in. Not so fast. Many of the benefits attributed uniquely to microservices are actually a byproduct of other architectural paradigms with modularity at their core.
In this session, we’ll look at several of the benefits we expect from today’s architectures and explore these benefits in the context of various modern architectural paradigms. We’ll also examine different technologies that are applying these principles to build the platforms and frameworks we will use going forward.
Along the way, we’ll explore how to refactor a monolithic application using specific modularity patterns and illustrate how an underlying set of principles span several architectural paradigms. The result is an unparalleled degree of architectural agility to move between different architectural paradigms.
Software architecture is having a moment, from best selling books to packed classes, the software industry acknowledges the importance of the parts of software resistant to internet searches. Ample pixels have been spilt talking about patterns, decomposition, styles, diagrams and more and all to good ends!
When it is time to review an architecture, what should you do? What factors should you consider? How do provide constructive feedback? We won’t just talk theory, we’ll work through real world examples, providing you chance to practice this vital skill.
Enterprise Architecture helps in describing what is the current state and helps build a future roadmap. Come prepared to solve many Enterprise Architecture challenges.
As part of the journey, we will explore TOGAF to build our architecture. First, we will create a Baseline Architecture. Next, we will explore the path for the Target Architecture. Finally, after identifying gaps between the two, we will apply a step-by-step process to prepare a roadmap.
“Organizations no longer want their enterprise architecture (EA) practice to be focused on standards, structure and control,” says Marcus Blosch, research vice president at Gartner.
“They want an EA practice that is focused on driving business outcomes, working in a flexible and creative way to help define the future and how to get there.”
We will explore the following domains:
– Data
– Technology
– Application
– Business
This talk will help you build a long-term IT Strategy which matches your Business Strategy.
In this dynamic talk, we explore the fusion of AI, particularly ChatGPT, with data-intensive architectures. The discussion covers the enhancement of big data processing and storage, the integration of AI in distributed data systems like Hadoop and Spark, and the impact of AI on data privacy and security. Emphasizing AI's role in optimizing big data pipelines, the talk includes real-world case studies, culminating in a forward-looking Q&A session on the future of AI in big data.
This talk delves into the innovative integration of advanced AI models like ChatGPT into data-intensive architectures. It begins with an introduction to the significance of big data in modern business and the role of AI in scaling data solutions. The talk then discusses the challenges and strategies in architecting big data processing and storage systems, highlighting how AI models can enhance data processing efficiency.
A significant portion of the talk is dedicated to exploring distributed data systems and frameworks, such as Apache Hadoop and Spark, and how ChatGPT can be utilized within these frameworks for improved parallel data processing and analysis. The discussion also covers the critical aspects of data privacy and security in big data architectures, especially considering the implications of integrating AI technologies like ChatGPT.
The talk further delves into best practices for managing and optimizing big data pipelines, emphasizing the role of AI in automating data workflow, managing data lineage, and optimizing data partitioning techniques. Real-world case studies are presented to illustrate the successful implementation of AI-enhanced data-intensive architectures in various industries.
Introduction (10 mins)
Part 1: Architecting for Big Data Processing and Storage (25 mins)
Part 2: Distributed Data Systems and Frameworks (25 mins)
Part 3: Handling Data Privacy and Security in Big Data Architectures (20 mins)
Part 4: Best Practices for Managing and Optimizing Big Data Pipelines (20 mins)
Case Studies and Real-World Applications (10 mins)
Conclusion and Q&A (10 mins)
Overall, this talk aims to provide a comprehensive understanding of how AI, especially ChatGPT, can be integrated into data-intensive architectures to enhance big data processing, analysis, and management, preparing attendees to harness AI's potential in their big data endeavors.
Key Takeaways:
“By 2030, 80 percent of heritage financial services firms will go out of business, become commoditized, or exist only formally but not competing effectively”, predicts Gartner.
This session explores the integration of AI, specifically ChatGPT, into cloud adoption frameworks to modernize legacy systems. Learn how to leverage AWS Cloud Adoption Framework (CAF) 3.0, Microsoft Cloud Adoption Framework for Azure, and Google Cloud Adoption Framework to build cloud-native architectures that maximize scalability, flexibility, and security. Designed for architects, technical leads, and senior IT professionals, this talk provides actionable insights and strategies for successful digital transformation.
Cloud adoption frameworks are essential for accelerating digital business transformation by leveraging the power of cloud technologies. This talk will guide you through the AWS Cloud Adoption Framework (CAF) 3.0, Microsoft Cloud Adoption Framework for Azure, and Google Cloud Adoption Framework, focusing on building cloud-native architectures that ensure scalability, flexibility, and security.
The session will delve into the strategic role of AI, particularly ChatGPT, in modernizing legacy systems. By understanding and implementing these frameworks, you will learn to navigate the complexities of transitioning from legacy systems to modern cloud-based architectures. This talk will provide practical steps and real-world case studies to help you effectively plan and execute your cloud adoption strategy.
Legacy systems can be assets and obstacles, providing reliable functionality but often becoming burdensome to maintain and evolve. In this talk, we will confront the challenges of working with legacy architectures and discover the strategic approaches for modernization. By examining the benefits and risks of incremental migration versus full system rewrites, attendees will learn the most suitable path for their unique situations.
Through practical examples and case studies, we will explore how successful organizations have revitalized their aging architectures, preserving the value of legacy investments while embracing innovation and adaptability. From small-scale legacy components to large-scale monolithic systems, we'll cover diverse modernization scenarios, allowing participants to glean insights applicable to their projects.
Whether your organization is facing budget constraints, a need for rapid modernization, or concerns about maintaining critical functionality, this talk offers a comprehensive guide to navigating the legacy landscape and crafting a roadmap to rejuvenate aging architectures.
Participants will leave this session equipped with a robust understanding of how to leverage AI, particularly ChatGPT, in the context of legacy system modernization. You will gain strategic insights, practical tools, and actionable knowledge to lead your teams and projects towards successful, AI-enhanced modernization efforts, ensuring your organization remains competitive and agile in a rapidly evolving digital landscape.
This is a dynamic session exploring the integration of cutting-edge AI technologies into software architecture. This talk provides senior developers and architects with actionable insights on leveraging large language models like ChatGPT to enhance design processes, manage architectural tradeoffs, and achieve scalable, innovative solutions.
Overview of the session
Importance of large language models (LLMs) in software architecture
Introduction to ChatGPT and its relevance for software architects
Part 1:
The Role of Large Language Models in Software Architecture
Understanding the capabilities of LLMs like ChatGPT
Benefits of integrating LLMs in modern software development
Real-world examples of AI-enhanced software architecture
Part 2: Prompt Engineering for Architectural Tasks
Crafting effective prompts for ChatGPT
Strategies for creating precise and effective prompts
Examples of architectural prompts and their impact
Interactive Exercise: Participants craft and test their own prompts
Feedback and discussion on prompt effectiveness
Part 3: Optimizing Requirement Analysis with ChatGPT
Leveraging ChatGPT for requirement analysis and design
Integration of AI in empathizing with client needs and journey mapping
Cost estimations, compliance, security, and performance
Case Study: Using empathy map and customer journey map tools in conjunction with AI
Hands-On Exercise: Requirement analysis and design
Part 4: Managing Architectural Tradeoffs
Defining and understanding architectural tradeoffs
Exploring real-world tradeoff scenarios
Case Study 1: Scalability vs. Flexibility
Case Study 2: Time-to-Market vs. Maintainability
Leveraging AI insights to analyze tradeoffs
Group Discussion and Q&A
Part 5: Best Practices for Integrating AI in Software Architecture
Techniques for gathering and prioritizing project requirements
Aligning architectural decisions with business objectives
Evaluating risks and potential outcomes of tradeoffs
Assessing tools, technologies, and architectural patterns
AI-powered decision support with ChatGPT
Collaborative decision-making and involving stakeholders
Part 6: Achieving Sustainable Innovation
Leveraging tradeoffs to drive innovation and creativity
Recap of key points and takeaways
Panel Discussion with Industry Experts
AI in architectural innovation: ChatGPT in action
Q&A and Open Discussion with the Audience
Conclusion
Recapitulation of key takeaways
Addressing final questions and facilitating discussions with the audience
Highlighting the future of AI and big data with technologies like ChatGPT
Architecture is often described as “the stuff that's hard to change” or “the important stuff (whatever that is).” At its core, architecture defines the very essence of software, transcending mere features and functions to encompass vital capabilities such as scalability, evolvability, elasticity, and reliability. But here's the real question: where do these critical capabilities truly originate?
In this session, we'll embark on a journey to uncover the secrets behind successful architectures. While popular architecture patterns may offer a starting point, it's time to unveil the startling truth – both monolith and microservicesbased projects continue to stumble and falter at alarming rates. The key to unparalleled success lies in the art of finetuning and tailormaking architectures to precisely fit the unique needs of your organization, environment, and the teams delivering the software.
Step into the future as we introduce a groundbreaking, problemcentric approach to defining and evolving system architectures. Our practical techniques will empower you to transform constraints, both architectural and environmental, into powerful enablers of robust, valuable, and longlived software systems.
Join us and elevate your architecture game to new heights!
Effective software development requires that we keep code and people in balance so that one supports the other. Yet, this equilibrium often eludes us, leading to coordination challenges, tightly interconnected services, and fragile code which is painful to change.Such challenges stem from the fact that the organization which builds the system is invisible in the code itself. Without a clear view of this social dimension, we're left grappling with surface-level fixes rather than addressing the root causes. What if we could visualize this intersection of code and people?
This keynote tackles that challenge head-on by introducing the concept of behavioral code analysis. By combining technical metrics with patterns extracted from Git repositories and insights from social psychology, you'll gain the data-driven ability to identify modules requiring excessive coordination, evaluate microservice boundaries, design modular monoliths, as well as practical solutions for rectifying these issues. Not only will you see these techniques in action on real-world codebase, you will also leave with a newfound arsenal of architectural analysis techniques.
Creating good design take effort and is an incremental process. Red-green-refactor is the mantra of TDD. As we continue to evolve the design, how do we know if the design needs some tweaking, or a lot, or is in a pretty good shape… from the extensibility and maintainability point of view. This is where measuring the quality of design comes in.
In this workshop we will start with a quick discussion of some fundamental characteristics that provide for better design, how to measure them, and how to keep an eye on them as we refactor and evolve the design. We will work with practical code examples to measure, refactor, and revaluate the quality of design.
In this workshop, take a practical approach to creating fitness functions that assess the architectural soundness of your systems.
We will learn about different fitness functions that can help architects and their teams create and comply with the architectural expectations expressed by their architect in collaboration with the team. Then we’ll see how we can implement those constraints, as guardrails, using ArchUnit, and get a continuous feedback on the teams' efforts.
git client
Java 8 or newer
Your favorite IDE, IntelliJ IDEA community edition recommended.
In this workshop, take a practical approach to creating fitness functions that assess the architectural soundness of your systems.
We will learn about different fitness functions that can help architects and their teams create and comply with the architectural expectations expressed by their architect in collaboration with the team. Then we’ll see how we can implement those constraints, as guardrails, using ArchUnit, and get a continuous feedback on the teams' efforts.
git client
Java 8 or newer
Your favorite IDE, IntelliJ IDEA community edition recommended.
Prioritizing technical debt is a hard problem as modern systems might have millions of lines of code and multiple development teams — no one has a holistic overview. In addition, there's always a trade-off between improving existing code versus adding new features so we need to use our time wisely.
What if we could mine the collective intelligence of all contributing programmers and start making decisions based on information from how the organization actually works with the code?
In this workshop, you'll learn how easily obtained version-control data lets you uncover the behavior and patterns of the development organization. This language-neutral approach lets you prioritize the parts of your system that benefit the most from improvements so that you can balance short- and long-term goals guided by data.
In this session, you’ll learn:
To prioritize technical debt in large-scale systems
Balance the trade-off between improving existing code versus adding new features
Visualize long time trends in technical debt
Take a data-driven approach to technical debt.
During this workshop, you get access to CodeScene – a behavioral code analysis tool that automates the analyses – which we use for the practical exercises. We’ll do the exercises on real world codebases in Java, C#, JavaScript and more to discover real issues.
Participants are also encouraged to take this opportunity to analyze their own codebase to get actionable take-away information.
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.
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. If you are curious about what this tool has to offer, this session is for you. Come on in, and let's learn how to terraform your cloud.
This session will focus on Terraform. We will look in to how this tool works, explore its capabilities, and see how it can play a pivotal role in our Infrastructure-as-Code (IaC) strategy. With lots of code and demos, this session will certainly give you enough fodder for thought, and provide a baseline so you can decide if Terraform is right for you.
Serverless doesn’t mean there are no servers. It’s a metaphor for a way of building applications.
In this presentation, we'll start with a short introduction to Serverless Cloud Functions and what it means to developers, and why it's important to understand this technology. We will discuss how serverless fits into the world of Microservices, and examine the pyramid of application development and deployment. We’ll put on our architect hat, and also look at Serverless options and how it impacts applications architecture.
Canary Deployments are the last ingredient of any Continuous Delivery or Continuous Deployment rollout. A canary deployment is a deployment strategy that releases an application or service incrementally to a subset of users. All infrastructure in a target environment is updated in small phases (e.g., 2%, 25%, 75%, 100%). This control makes a canary release the lowest risk-prone compared to all other deployment strategies, like the blue-green strategy. If you need to back out of a production deployment quickly without much disruption, then canary deployments may be an excellent practice to set up.
We will treat this talk like a recipe so that you can set up a canary in your work environment.
Domain Driven Design has been guiding large development projects since 2003, when the seminal book by Eric Evans came out. Domain Driven Design is split up into two parts: Strategic and Tactical. One of the issues is that the Strategic part becomes so involved and intense that we lose focus on implementing these sorts of things. This presentation swaps this focus as topic pairs. For example, when we create a bounded context, is that a microservice or part of the subdomain? When we create a domain event, what does that eventually become? How do other tactical patterns fit into what we decide in the strategic phase?
In this workshop, we will break it down into pairs of topics.
In this workshop, we will perform the following activities
Domain Driven Design has been guiding large development projects since 2003, when the seminal book by Eric Evans came out. Domain Driven Design is split up into two parts: Strategic and Tactical. One of the issues is that the Strategic part becomes so involved and intense that we lose focus on implementing these sorts of things. This presentation swaps this focus as topic pairs. For example, when we create a bounded context, is that a microservice or part of the subdomain? When we create a domain event, what does that eventually become? How do other tactical patterns fit into what we decide in the strategic phase?
In this workshop, we will break it down into pairs of topics.
In this workshop, we will perform the following activities
It’s inescapable. The capabilities that ChatGPT and Large Language Models provide have become discussion topics on the news, in social gatherings, online, at work. Things that would have seemed impossible a few years ago are now nearly pedestrian in how ubiquitous they are becoming on a daily basis. While they show very well, very few people actually understand what is going on, and worse, what is or isn’t possible.
Additionally, there are concerns about the costs involved, the security risks, and the inherent latencies of cloud-based systems. There are additional costs that are not factored into model deployments that we need to consider as well. How do the trends in IT of increased parallelization, heterogeneity, and distributed systems impact the use of these models?
How should we evaluate these achievements as we make decisions on how to adopt and adapt to powerful new technologies? What will they mean for us as a society and as individual knowledge workers? In addition to a discussion specifically about ChatGPT and its peer technologies and what they portend, we will
also discuss critically evaluating new technology as we make decisions in the future.
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.
It’s inescapable. The capabilities that ChatGPT and Large Language Models provide have become discussion topics on the news, in social gatherings, online, at work. Things that would have seemed impossible a few years ago are now nearly pedestrian in how ubiquitous they are becoming on a daily basis. While they show very well, very few people actually understand what is going on, and worse, what is or isn’t possible.
How then should we evaluate these achievements as we make decisions on how to adopt and adapt to powerful new technologies? What will they mean for us as a society and as individual knowledge workers? In addition to a discussion specifically about ChatGPT and its peer technologies and what they portend, we will also discuss critically evaluating new technology as make decisions in the future.
Learning Objectives:
After attending this talk, you will be able to:
Explain what Large Language Models (LLMs) are and how they are used
Understand intuitively how they are built and work
Understand where they fit into the overall history of natural language processing
Understand the use cases where they are effective and appropriate in modern Enterprises
Understand the limitations of these models and how they can go wrong
Understand the moral, ethical, and legal complications that surround the development and use of these models
Understand the externalities of developing and operating these models which are often not priced into the fancy demos
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.