In the realm of architecture, principles form the bedrock upon which innovative and enduring designs are crafted. This presentation delves into the core architectural principles that guide the creation of structures both functional and aesthetic. Exploring concepts such as balance, proportion, harmony, and sustainability, attendees will gain profound insights into the art and science of architectural design. Through real-world examples and practical applications, this session illuminates the transformative power of adhering to these principles, shaping not only buildings but entire environments. Join us as we unravel the secrets behind architectural mastery and the principles that define architectural brilliance.
Good architectural principles are fundamental guidelines or rules that inform the design and development of software systems, ensuring they are scalable, maintainable, and adaptable. Here are some key architectural principles that are generally considered valuable in software development:
Adhering to these architectural principles can lead to the development of robust, maintainable, and adaptable software systems that meet the needs of users and stakeholders effectively.
Embarking on the journey to become an architect requires more than technical expertise; it demands a diverse skill set that combines creativity, leadership, communication, and adaptability. You may be awesome as a developer or engineer, but the skills needed to be an architect are often different and require more than technical awareness to succeed.
This presentation delves into the crucial skills aspiring architects need to cultivate. From mastering design principles and embracing cutting-edge technologies to honing collaboration and project management abilities, attendees will gain valuable insights into the multifaceted world of architectural skills. Join us as we explore practical strategies, real-world examples, and actionable tips that pave the way for aspiring architects to thrive in a dynamic and competitive industry.
In today's rapidly evolving technological world, architects play pivotal roles in shaping the success of organizations. This presentation explores the diverse spectrum of architects, ranging from Enterprise Architects and Solution Architects to UX Architects and Security Architects. Delving into their unique responsibilities and expertise, this session sheds light on how these professionals align business objectives with technology, design innovative solutions, and ensure seamless integration. By understanding the multifaceted roles of architects, attendees will gain valuable insights into how these experts drive efficiency, foster innovation, and architect the future of modern enterprises.
This session will outline the importance of Architectural Roles by diving into different roles and responsibilities including the value that each role brings to larger enterprises. The roles that will be covered include:
In addition, We will take time to discuss common challenges faced by Architects.
In the age of digital transformation, Cloud Architects emerge as architects of the virtual realm, bridging innovation with infrastructure. This presentation offers a comprehensive exploration of the Cloud Architect's pivotal role.
Delving into cloud computing models, architecture design, and best practices, attendees will gain insights into harnessing the power of cloud technologies. From optimizing scalability and ensuring security to enhancing efficiency and reducing costs, this session unravels the strategic decisions and technical expertise that define a Cloud Architect's journey. Join us as we decode the nuances of cloud architecture, illustrating its transformative impact on businesses in the modern era.
In the ever-changing landscape of technology, Solution Architects stand as the linchpin between complex business challenges and innovative technological solutions. This presentation dives deep into the world of Solution Architects, exploring their pivotal role in crafting tailored, efficient, and scalable solutions. From deciphering intricate business requirements to orchestrating seamless integrations, Solution Architects navigate a maze of technologies to deliver outcomes that align perfectly with organizational goals. Join us as we unravel the key responsibilities, skills, and methodologies that empower Solution Architects to transform abstract ideas into tangible, impactful solutions, shaping the future of businesses in a digital age.
In this session we will walk thru the following:
Whether you are an existing Solution Architect looking to hone or validate your skills or you are looking to get into the role of Solution Architect, this session is for you!
No matter the techniques used to make enterprise solutions Highly Available (HA), failure is inevitable at some point. Resiliency refers to how quickly a system reacts to and recovers from such failures. This presentation discusses various architectural resiliency techniques and patterns that help increase Mean Time to Failure (MTTF), also known as Fault Tolerance, and decrease Mean Time to Recovery (MTTR).
Failure of Highly Available (HA) enterprise solutions is inevitable. However, in today's highly interconnected global economy, uptime is crucial. The impact of downtime is amplified when considering Service Level Agreement (SLA) penalties and lost revenue. Even more damaging is the harm to an organization's reputation as frustrated customers express their grievances on social media. Resiliency, often overlooked in favor of availability, is essential. Prezi Presentation
In this session, we will discuss architectural concerns regarding security. How do microservices communicate with one another securely? What are some of the checklist items that you need?
This session will focus on data governance and making data available within your enterprise. Who owns the data, how do we obtain the data, and what does governance look like?
This presentation will discuss the patterns required when things go wrong in architecture and how to stay resilient under pressure. These are battle-tested patterns that every architect should know.
Join us for an indepth exploration of cuttingedge messaging styles in your large domain.
Here, we will discuss the messaging styles you can use in your business.
We take a look at another facet of architectural design, and that is how we develop and maintain transactions in architecture. Here we will discuss some common patterns for transactions
Creating Microservices is hard and it takes more effort.
In this presentation, we will distill some design and architectural patterns that can help us with that journey. We can learn from some proven solutions that can help us to avoid common mistakes and also help us gravitate toward focusing on the essential problems that are inherent to the Microservices architecture.
It almost feels like we keep hearing this chant “Monoliths are bad, Microservices are awesome.” When architects, technical leads, and developers reject architecture due to bias or favor due to infatuation organizations lose. The most important question is what are the business needs and which architecture is the most suitable for that.
In this presentation we will compare the contrast the differences between monoliths and microservices and the consequences of choosing one over the other. The goal is for us to develop an objective knowledge so we can choose wisely in order to serve our businesses.
In this session we will discuss the need to document architecture, and see what mechanisms are available to us to document architecture—both present and future.
We've all learned that documenting your code is a good idea. But what about your architecture? What should we be thinking about when we document architecture? What tools and techniques can we reach for as we pursue this endeavor? Can we even make this a sustainable activity, or are we forever doomed to architectural documentation getting outdated before the ink is even dry?
In this session we will discuss a range of techniques that will not only help document your architecture, but even provide a mechanism to think about architecture upfront, and make it more predictable. You'll walk away armed with everything you need to know about documenting your current, and future architectures.
In this session we will discuss what modular monoliths are, what they bring to the table, and how they offer a great middle ground between monoliths and distributed architectures like microservices.
Monoliths get a bad rep. Experienced software developers have seen one too many monoliths devolve into a big ball of mud, leaving everyone frustrated, with an itch to do a “rewrite”. But monoliths have their pros! They are usually simpler, easier to understand, and faster to build and debug.
On the other side of the spectrum you have microservices—that offer scale, both technically and organizationally, as well as having the badge of honor of being “the new cool kid on the block”. But productionizing microservices is HARD.
Why can't we have our cake and eat it too? Turns out, we can. In this session we will explore the modular monolith—all the upsides of a monolith with none of the downsides of distributed architectures. We'll see what it means to build a modular monolith, and how that differs from a traditional layered architecture. We will discuss how we can build architectural governance to ensure our modules remain decoupled. Finally we'll see how our modules can communicate with one another without violating modularity.
By the end of this session you'll walk away with a greater appreciation for the monolith, and see how you can leverage this within your system architecture.
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
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.
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.
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.
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!
In 2017, an organization known as The Semantic Arts published their “datacentric manifesto” leading with this paragraph.
> “We have uncovered a root cause of the messy state of Information Architecture in large institutions and on the web today. It is the prevailing applicationcentric mindset that gives applications priority over data. The remedy is to flip this on its head. Data is the center of the universe; applications are ephemeral.”
While the vision and ideas of this manifesto are compelling, implementation details are scarce leaving the potential out of reach of many busy developers and architects.
Datacentric is a major departure from the current applicationcentric approach to systems development and management. Migration to the datacentric approach will not happen by itself.
This session is full of practical and actionable examples, insights, and approaches to this new paradigm. If you’re ready to consider the possibility that systems could be more than an order of magnitude cheaper and more flexible, then check out this session to see firsthand a new way to think about software and information systems.
Technologists tend to think of end-to-end as meaning the UI to the database from client to server. But a true architect realizes end to end means from idea to retirement. The architect has to traverse a lot of territory in that journey, from business to technology. They have to work through change management, complex stakeholder dynamics, systems of systems and of course technical decisions.
This introduction to the end-to-end architect will prepare you with the 5 pillars of architecture as well as help you understand how to navigate the complexity of end-to-end architecture work!
I've witnessed firsthand the challenges and opportunities faced by companies navigating the complex world of legacy systems.
In this session, I'll draw on my years of experience to:
Define the “legacy landscape”: We'll explore the different types of legacy systems, their impact on businesses, and the unique challenges they present for technology teams. We will also distinguish between legacy and technical debt. We will show practical and actionable tools to extract legacy ‘reasoning’ and ‘design’ and transform them into moder landscapes.
Understand the business context: We'll shift perspectives, examining how legacy systems support core business functions and value propositions. Extracting out of a legacy system is essential. And the core capabilities it supports even more so.
Bridge the gap: Technology delivery strategies: We'll delve into practical strategies for delivering technology value within a legacy environment, including:
Modernization techniques: Refactoring, microservices, and API integration.
Legacy coexistence strategies: Leveraging existing investments while adopting new technologies.
Change management considerations: Aligning stakeholders, navigating risk,and ensuring adoption.
Real-world case studies: Learn from real-world examples of companies successfully delivering technology value in legacy environments.
Open discussion: Share your own challenges and experiences, and engage in a collaborative discussion about navigating the legacy landscape.
As CEO of Iasa, the world's largest professional association for architects, and champion of the BTABoK (Business Technology Architecture Body of Knowledge), I've witnessed firsthand the dynamic interplay between engineering and architecture in today's complex projects. In this session, we'll dance on the edge of these disciplines, using the BTABoK as our guiding framework, exploring how agile practices, decisive engineering, efficient delivery, and the delicate balance of hands-on/hands-off leadership intertwine.
Defining the modern dance: We'll explore the shifting ground where agile methodologies meet traditional engineering rigor, and how architects leverage the BTABoK's 5 Pillars of Architecture Skill (Business Strategy, Technology Strategy,Solution Design, Delivery & Operations, and Value Management) to navigate the tension inherent in the roles. We will also dive into the healthy and natural balance between engineereing and architecture and why it is so essential to modern systems success.
Understanding the business waltz: We'll shift perspectives, examining how business objectives and user needs inform the interaction between agility and precision in complex projects, aligning with the BTABoK's emphasis on strategic value delivery.
Change Management and Architecture: We'll look into practical strategies for managing the roadmap and delivery of a project including:
Harmonizing delivery: Finding the sweet spot between iterative sprints and long-term vision, as outlined in the Delivery & Operations pillar.
Hands-on leadership: Empowering teams while providing strategic guidance,aligning with the Leadership and People skills.
Technical Excellence: Ensuring high-quality engineering practices within an agile framework, leveraging the BTABoK's Technology pillar.
Human Systems: Addressing unforeseen challenges and navigating changing requirements, a key competency in the BTABoK's Solution Design pillar.
Case studies from the architectural stage: Learn from real-world examples of successful projects where architects mastered the interaction between agility and engineering excellence, demonstrating the practical application of the BTABoK principles.
Open discussion: Share your own experiences and challenges, and engage in a collaborative conversation about navigating the complexities of modern architecture, applying the BTABoK's collaborative and knowledge-sharing principles.
This session is for you if you are:
A senior developer or technology leader working with legacy systems.
A senior architect looking at a portfolio of change and large structural systems delivery.
Responsible for delivering new technology solutions in a complex, existing environment.
Keen to gain practical strategies and actionable insights from a business and technical perspective.
With advanced AI tools, software architects can enhance their project design, compliance adherence, and overall workflow efficiency. Join Rohit Bhardwaj, an expert in generative AI, for a session that delves into the integration of ChatGPT, a cutting-edge generative AI model, into the realm of software architecture. The session aims to provide attendees with hands-on experience in prompt engineering for architectural tasks and optimizing requirement analysis using ChatGPT. It is a compelling talk explicitly designed for software architects who are interested in leveraging generative AI to improve their work.
Outline:
Introduction
A brief overview of the session.
Importance of generative AI in software architecture.
Introduction to ChatGPT and its relevance for software architects.
Prompt Engineering for Architectural Tasks
Crafting Effective Prompts for ChatGPT
Strategies for creating precise and effective prompts.
Examples of architectural prompts and their impact.
Hands-On Exercise: Creating Architectural Prompts
Interactive session: Participants will craft and test their prompts.
Feedback and discussion on prompt effectiveness.
Optimizing Requirement Analysis
Leveraging ChatGPT for Requirement Analysis and Design
Integration of AI in empathizing with client needs and journey mapping.
Cost Estimations, Compliance, Security, and Performance
Selecting appropriate technologies and patterns with AI assistance
Hands-On Exercise: Requirement Analysis and Design
Case Study
Using Empathy Map and Customer Journey Map tools in conjunction with AI.
Case Study Cost Estimations, Compliance, Security, and Performance
Custom GPTs, Embeddings, Agents
Key Takeaways:
Enhanced understanding of how generative AI can be used in software architecture.
Practical skills in prompt engineering tailored for architectural tasks.
Strategies for effectively integrating ChatGPT into requirement analysis processes.
Graph technology has emerged as the fastest-growing sector in database systems over the past decade—and now, it's at the heart of AI transformation. This talk explores the strategic imperative of mastering graph technologies for professionals designing intelligent systems, optimizing codebases, and architecting future-ready enterprises.
Mastering graph databases, knowledge graphs, and advanced algorithms is no longer a niche skill—it's foundational to enabling AI use cases, powering semantic search, driving recommendation engines, and orchestrating Retrieval-Augmented Generation (RAG) with high precision.
In this comprehensive session, we'll explore high-level graph algorithms that form the backbone of modern, complex systems and discuss how these algorithms are integral to the architecture of efficient graph databases. We will delve into the advanced functionalities and strategic implementations of knowledge graphs, illustrating their essential role in integrating disparate data sources, empowering AI applications including generative AI, and enhancing business intelligence.
Join us to navigate the complexities and opportunities this dynamic field presents, ensuring you remain at the cutting edge of technology and continue to drive significant advancements in your projects and enterprises.
What You’ll Learn:
Advanced Graph Algorithms
Concise review of key graph theory concepts tailored for AI and data engineers.
Application of algorithms like Greedy, Dijkstra's, Bellman-Ford, and PageRank for real-world graph optimization, pathfinding, and influence modeling.
Graph Database Architecture
Comparison of graph vs. relational models for large-scale, interconnected data.
Best practices in data modeling, indexing, and query performance tuning in platforms like Neo4j, TigerGraph, and Amazon Neptune.
Mastery of Knowledge Graphs
How to build and scale enterprise-grade knowledge graphs for semantic search, personalization, and intelligent recommendations.
Role of ontologies, entities, and relationships in structuring organizational knowledge.
Graph-RAG and AI-Enhanced Use Cases
Deep dive into Graph-RAG (Graph-enhanced Retrieval-Augmented Generation): combining structured knowledge graphs with unstructured retrieval to power trustworthy, explainable generative AI.
Use cases:
Domain-specific copilots with traceable knowledge lineage.
AI assistants that reason over connected knowledge.
Compliance-aware search and recommendations.
Customer 360 + Agent 360 views for enterprise workflows.
Case Studies and Future Technologies
Real-world case studies of graph adoption in healthcare, finance, e-commerce, and public sector AI.
Preview of emerging trends:
Graph Neural Networks (GNNs)
Hybrid vector–graph databases
Multimodal reasoning over structured + unstructured data
Outcomes & Takeaways:
By the end of this session, you will:
Understand why graph mastery is foundational for AI and system innovation.
Learn to architect performant, scalable graph systems for enterprise use.
See how Graph-RAG bridges structured knowledge and LLMs to deliver smarter AI assistants.
Be equipped to apply graph technologies to drive innovation, efficiency, and AI trustworthiness in your own organization.
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
Join us for a transformative captivating session where you'll embark on a journey of discovery as we unveil a comprehensive seven-step methodology designed to revolutionize your approach to API design and implementation.
Throughout the session, we'll explore practical use cases drawn from diverse industries, allowing you to gain valuable insights into the intricacies of designing APIs for real-world scenarios. From taxi hailing giants like Uber and Lyft to social media titans such as Facebook and Instagram, you'll dissect the unique challenges and requirements driving API design in today's dynamic digital landscape.
Guided by seasoned industry experts, you'll delve into the core principles of RESTful microservices architecture and learn how to apply them effectively in your own projects. Through engaging presentations, interactive exercises, and hands-on, you'll master essential concepts such as OData integration, industry best practices, and innovative design strategies.
By the end of the session, you'll emerge with a deep understanding of the seven-step process for designing superior cloud-native RESTful microservices APIs. Armed with practical insights and invaluable experience, you'll be ready to tackle the challenges of modern software architecture head-on, driving innovation and excellence within your organization.
Don't miss this opportunity to elevate your skills, expand your knowledge, and unlock the full potential of RESTful microservices architecture. Join us and take the first step towards architectural mastery today!
– Seven-Step Methodology to Design RESTful Microservices APIs
Embark on our journey with a comprehensive overview of the seven-step methodology crucial for crafting robust and scalable RESTful microservices APIs. Learn how to navigate the intricacies of API development while adhering to industry best practices, setting the foundation for success in your microservices architecture endeavors.
Exercise: Industry Best Practices for API Development
Put your newfound knowledge into action as we delve into hands-on exercises designed to reinforce industry best practices for API development. Gain practical insights and hone your skills in designing APIs that meet the highest standards of performance and scalability.
– Unveiling OData - The Best Way to REST
Explore the power of OData (Open Data Protocol) as we unravel its capabilities and advantages in building RESTful microservices. Discover how OData simplifies data access and manipulation, offering unparalleled flexibility and efficiency in your API design endeavors.
Exercise: Online Ecommerce API Design
Engage in a real-world exercise focusing on online ecommerce API design, where you'll apply OData principles to create seamless and intuitive API solutions tailored for the digital marketplace.
– Understanding Use Cases
Delve into the realm of practical use cases as we analyze scenarios from industries like taxi hailing (Uber/Lyft) and social media (Facebook/Instagram). Gain insights into the unique challenges and requirements driving API design in these domains.
Exercise: Use Case Exploration
Immerse yourself in hands-on exercises exploring use cases for taxi hailing and social media companies. Apply your newfound knowledge to design APIs that address specific challenges and optimize performance in these dynamic environments.
Designing Taxi Hailing APIs - Uber/Lyft
Deep dive into the intricacies of designing APIs for taxi hailing services like Uber and Lyft. Explore real-world examples and best practices for architecting APIs that facilitate seamless interactions between users, drivers, and the platform.
Exercise: Design Challenges
Challenge yourself with hands-on design exercises focused on tackling real-world challenges such as duplicate records, data migration, large data volume considerations, data rate limits, decision-making, and data validations.
– Navigating API Challenges
Navigate through the complexities of API challenges as we dissect common pitfalls and obstacles encountered in RESTful microservices architecture. Gain strategies and insights to overcome these challenges and optimize your API solutions for maximum efficiency and scalability.
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.
In the fast-moving world of API development, the right tools can make all the difference—especially in the age of AI. As automation accelerates and complexity grows, it’s never been more important to equip your teams with tools that support clarity, consistency, and velocity. This session explores a curated set of essential tools that every API practitioner should know—spanning the entire API lifecycle. From design and development to governance, documentation, and collaboration, we’ll highlight solutions that boost productivity and support scalable, AI-ready API practices. Whether you're refining your stack or starting from scratch, this toolkit will help you deliver better APIs, faster.
Join to discover how this essential toolkit can empower your API journey, enhancing productivity and ensuring optimal performance throughout the API lifecycle.
In an era where digital transformation and AI adoption are accelerating across every industry, the need for consistent, scalable, and robust APIs has never been more critical. AI-powered tools—whether generating code, creating documentation, or integrating services—rely heavily on clean, well-structured API specifications to function effectively. As teams grow and the number of APIs multiplies, maintaining design consistency becomes a foundational requirement not just for human developers, but also for enabling reliable, intelligent automation. This session explores how linting and reusable models can help teams meet that challenge at scale.
We will explore API linting using the open-source Spectral project to enable teams to identify and rectify inconsistencies during design. In tandem, we will navigate the need for reusable models—recognizing that the best specification is the one you don’t have to write or lint at all! These two approaches not only facilitate the smooth integration of services but also foster collaboration across teams by providing a shared, consistent foundation.
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.
“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.
In the rapidly evolving field of software architecture, the difference between theory and practice has never been more pronounced. Despite a wealth of knowledge, architects and systems designers face an alarming rate of project failures, underscoring the need for a more nuanced approach to architecture and system design.
We invite you to embark on a transformative threeday journey with this upcoming “Holistic Software Architecture masterclass,” designed for those ready to significantly enhance their effectiveness in the realm of software architecture, leadership, and system design.
This workshop transcends traditional patterns and fragmented methodologies, focusing instead on a holistic strategy that addresses the specific needs of complex software problems. We delve into the core of software architecture, moving beyond the surfacelevel patterns and technologies to explore the hidden and external factors that influence project success. The piecemeal, statusquo of software architecture methodologies are unified into a new, holistic approach with the TailorMade software architecture model.
Mastery Over Complexity: Learn to navigate the multifaceted challenges of software architecture, from deriving tailormade solutions that meet unique project requirements to conducting tradeoff analysis for informed decisionmaking.
A New Toolbox: Arm yourself with new tools, models, and techniques aimed at reducing risk and uncertainty, transforming constraints into enablers for robust and valuable software systems.
Strategic Insights: Gain practical insights into architectural styles, distributed systems, and the interplay between business needs and architectural decisions, all while aligning your enterprise's objectives.
RealWorld Application: Engage with realworld case studies and exercises that bring theoretical concepts to life, enhancing your practice with actionable knowledge.
Communicative Excellence: Elevate your communication skills, ensuring you can articulate your vision clearly, build consensus across teams, and navigate the complex terrain of software engineering.
Innovative Approach: Our workshop offers a fresh, practical perspective that cuts through the traditional solutioncentric methodologies, providing a roadmap to deterministic results and highly predictable outcomes.
Comprehensive Understanding: Delve into the architectural process, acknowledging organizational and environmental considerations for a rounded perspective on design and execution.
The Architect’s Toolbox: Beyond imparting knowledge, this workshop equips you with longlived mental and problemsolving tools, empowering you to make impactful architectural decisions.
Communicative Competence: Learn to effectively communicate your architectural vision, aligning with business needs and facilitating smooth implementation.
Whether you’re an aspiring architect seeking to broaden your horizons or an experienced practitioner aiming to refine your skills, this workshop is designed to arm you with the mental models and tools necessary for success in today’s complex landscape.
Join us to elevate your role to that of an Architectural Artisan, skillfully navigating the challenges of modern software design. Your journey towards mastering tailormade software architecture starts here.
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
One of my favored punch lines is “you get the big ball of mud for free”. It is funny because most of us have to deal with big balls of mud on a daily base and are not too happy about it. Working on a big ball of mud literally makes everything harder and more complicated.
Those are just a few of the many issues with big balls of mud.
I think it is fair to say that most of us would prefer to work on a clean and well architected piece of software. So why is that so hard to achieve? Why do more than 80% of non-trivial projects end up as big balls of mud? And what can we do to guarantee that this never happens again to us? Aren’t micro-services supposed to solve this problem?
In this presentation, I will address all those questions and then explain some simple but proven strategies to avoid that dreaded outcome.
In the ever-evolving landscape of technology and Generative AI, integrating DevOps principles into the machine learning (ML) lifecycle is a transformative game-changer.
Join me for an insightful session where we will explore essential aspects such as mlflow, deployment patterns, and monitoring techniques for ML models. Gain a deeper understanding of how to effectively navigate the complexities of deploying ML models into production environments. Discover best practices and proven strategies for monitoring and observing ML models in real-world scenarios.
By attending this session, you will acquire valuable insights and practical knowledge to overcome the unique hurdles of scaling and bringing AI into production. Unlock the full potential of your ML models by embracing the powerful integration of DevOps principles. This presentation is based on the extensive customer research I conducted to write the Best Seller book - Scaling Machine Learning with Spark - https://www.amazon.com/Scaling-Machine-Learning-Spark-Distributed/dp/1098106822.
Designing a distributed system architecture can be a daunting task, with contradictory requirements and constraints constantly at play. The CAP theorem that directly states the challenges in distributed data stores presents a classic example where developers must choose between consistency, availability, and partition tolerance. The same applies to streaming infrastructure systems, where optimizing for one aspect can come at the cost of another. With cost, throughput, accuracy, and latency as the main constraints for streaming systems, it's crucial to make informed decisions that align with your business goals.
In this session, you'll gain valuable insights into how your system design choices impact your system overall capabilities. You'll also learn about the differences between Flink Streaming and Spark Streaming, both conceptually and in practice. Lastly, you'll understand how combining multiple solutions can be beneficial for your team and business. Join to learn more about the cumbersome world of distributed stream processing systems.
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:
This one-day deep dive workshop is tailored for software architects and developers aiming to accelerate their understanding and utilization of generative AI, explicitly focusing on ChatGPT. Through a series of intensive sessions and hands-on exercises, participants will delve into advanced applications of generative AI in software architecture, enhancing their ability to leverage this technology effectively in their projects and daily workflows.
Unlock the Future of Software Architecture with Cutting-Edge Generative AI Techniques!
Are you ready to revolutionize the way you approach software architecture? Join us for an exclusive one-day deep dive into the world of generative AI, meticulously crafted for forward-thinking professionals like you.
Why You Can't Afford to Miss This Opportunity:
Elevate Your Architectural Expertise: As a Software Architect, Enterprise Architect, Technical Lead, or Senior Developer, your skills define the success of your projects. Dive into the realm of generative AI and amplify your capabilities to unprecedented levels.
Gain Competitive Edge: In today's fast-paced tech landscape, staying ahead of the curve is paramount. Equip yourself with the latest advancements in AI technology, empowering you to lead with innovation and agility.
Turbocharge Productivity: Time is of the essence, and with ChatGPT as your ally, you'll witness a paradigm shift in your productivity. Streamline tasks, automate processes, and unlock hidden potentials within your architectural workflows.
Drive Strategic Decision-Making: IT Managers and professionals closely collaborating with architects understand the importance of informed decision-making. Harness the power of generative AI to derive actionable insights, fueling strategic initiatives and digital transformation efforts.
Future-proof Your Career: The era of AI-driven architecture is upon us, and those who embrace it early will shape the future of technology. Whether you're a seasoned architect or an aspiring AI enthusiast, this deep dive is your gateway to staying relevant and indispensable in the industry.
What You'll Experience:
Immersive Hands-On Learning: Dive deep into practical exercises guided by industry experts to master the art of crafting custom prompts, optimizing system designs, streamlining code reviews, and much more.
Exclusive Insights: Gain access to insider knowledge and real-world use cases, shedding light on how leading organizations are leveraging generative AI to drive architectural innovation and efficiency.
Who Should Attend:
Software Architects: Refine your skills and discover new avenues for architectural excellence.
Enterprise Architects: Unlock the full potential of generative AI to drive strategic initiatives and digital transformation at an enterprise level.
Technical Leads: Lead your teams with confidence, armed with the latest tools and techniques to deliver exceptional results.
Senior Developers: Take your development prowess to new heights by integrating generative AI into your workflows, fostering innovation and efficiency.
IT Managers: Navigate the complexities of modern technology landscapes with ease, leveraging AI-driven insights to make informed decisions and propel your organization forward.
Professionals Collaborating with Architects: Enhance your collaboration capabilities and contribute meaningfully to architectural endeavors with a deep understanding of generative AI principles.
Aspiring AI Enthusiasts: Whether you're just starting your journey or looking to expand your skill set, this deep dive is your gateway to becoming proficient in generative AI for architectural tasks.
Don't miss out on this transformative opportunity to redefine your approach to software architecture and position yourself as a leader in the AI-driven future. Secure your spot now and embark on a journey towards architectural excellence!
Decisions, decisions, decision, that's our live every day. But, what's worse than making a bad decision is not remembering why we made a decision, good or bad. Architectural Decision Records are highly important to document the decisions we make, to support the decisions, to bring in necessary and sufficient reasons, and to reevaluate decisions when the business requirements and/or the technologies change.
In this presentation we will look at ADRs, how to create them, how to maintain them, and the values they provide.
Creating microservices takes substantial effort but maintaining them in production takes a lot more time, cost, and effort. If we forget some key practices the results can be devastating for the organization and we end up hurting from the lack of the measures we can put in place to proactively address potential issues.
In this presentation we will discuss seven essential practices to make the journey of maintaining microservices in production.
With the prevalence of distributed systems, server less applications, and microservices, a greater emphasis is placed on asynchronous communication between applications and different parts of applications. One impact of asynchronous programming is scalability.
In this presentation we will take a few practical examples and see how asynchronous programming and a few modern developments can provide scalability with reduced resource demands. You can apply these ideas to your own applications, whether you are using, for example, Spring Boot or any other framework, and look at ways to attain better scale at reduced cost or resource usage.
By their very nature, distributed applications have to communicate. But, how do we exchange data and what are the consequences of choosing one solution over the other, in terms of ease, cost, impact on extensibility, and so much more.
In this presentation we will discuss different patterns, their benefits, and the consequences of using them.
Design Pattern evolve when languages and libraries evolve. There is no shortage of patterns but finding which one to apply, why, and how is a challenge.
In this workshop, learn to take a fresh look at patterns, when and how to use them, see them come to live in code, and how to make use of some of the modern capabilities of languages to implement a better set of patterns. Learn to leverage patterns to implement policies and rules that are common in applications.
Since ChatGPT rocketed the potential of generative AI into the collective consciousness there has been a race to add AI to everything. Every product owner has been salivating at the possibility of new AIPowered features. Every marketing department is chomping at the bit to add a “powered by AI” sticker to the website. For the average layperson playing with ChatGPT's conversational interface, it seems easy however integrating these tools securely, reliably, and in a costeffective manner requires much more than simply adding a chat interface. Moreover, getting consistent results from a chat interface is more than an art than a science. Ultimately, the chat interface is a nice gimmick to show off capabilities, but serious integration of these tools into most applications requires a more thoughtful approach.
This is not another “AI is Magic” cheerleading session, nor an overly critical analysis of the field. Instead, this session looks at a number of valid usecases for the tools and introduces architecture patterns for implementing these usecases. Throughout we will explore the tradeoffs of the patterns as well as the application of AI in each scenario. We'll explore usecases from simple, direct integrations to the more complex involving RAG and agentic systems.
Although this is an emerging field, the content is not theoretical. These are patterns that are being used in production both in Michael's practice as a handson software architect and beyond.
Architects must maintain their breadth, and this session will build on that to prepare you for the inevitable AIpowered project in your future.
Since ChatGPT rocketed the potential of generative AI into the collective consciousness there has been a race to add AI to everything. Every product owner has been salivating at the possibility of new AIPowered features. Every marketing department is chomping at the bit to add a “powered by AI” sticker to the website. For the average layperson playing with ChatGPT's conversational interface, it seems easy however integrating these tools securely, reliably, and in a costeffective manner requires much more than simply adding a chat interface. Moreover, getting consistent results from a chat interface is more than an art than a science. Ultimately, the chat interface is a nice gimmick to show off capabilities, but serious integration of these tools into most applications requires a more thoughtful approach.
This is not another “AI is Magic” cheerleading session, nor an overly critical analysis of the field. Instead, this session looks at a number of valid usecases for the tools and introduces architecture patterns for implementing these usecases. Throughout we will explore the tradeoffs of the patterns as well as the application of AI in each scenario. We'll explore usecases from simple, direct integrations to the more complex involving RAG and agentic systems.
Although this is an emerging field, the content is not theoretical. These are patterns that are being used in production both in Michael's practice as a handson software architect and beyond.
Architects must maintain their breadth, and this session will build on that to prepare you for the inevitable AIpowered project in your future.
A number of agile teams expect their technical staff to be cross functional and carry multiple responsibilities. In general that is good, however, there's still a significant role for an architect.
In this presentation we'll quickly discuss the consequences of not having someone at that role and move forward to discuss the benefits of having such a person. We will then discuss the responsibilities they should carry and how they can effectively hone their skills to serve in this critical role.
This talk explores how cutting-edge technologies and trends will shape the future of enterprise software development, creating opportunities for innovation and efficiency. We’ll discuss how to leverage these technologies within an Enterprise Architecture framework to build a robust roadmap that guides enterprises through technological advancements and competitive landscapes.
Introduction
Generative AI, Graph Databases, and Vector Databases
GPTs and Copilot GPTs
Augmented Reality (AR) & Virtual Reality (VR)
Edge Computing
Artificial Intelligence & Machine Learning (AI/ML)
Blockchain Technology
Agents and Advanced Automation
Preparing for the Future
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.
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 presentation, we will break it down into pairs of topics.
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.
The surging need for substantial compute resources, driven by progress in generative AI and genomic analyses, underscores the imperative for High-Performance Computing (HPC) systems to adapt. Historically optimized for on-premises environments with centralized resources, HPC frameworks are now compelled to undergo an evolutionary transition to harness cloud capabilities.
This shift towards cloud infrastructure promises unmatched scalability and adaptability, crucial for addressing the current dynamic demands in computation by melding HPC methodologies with the expansive scaling opportunities afforded by cloud-native services. This talk will delve into the progression of HPC patterns for enhanced performance through cloud-native services. It will offer insights and tangible examples of how the incorporation of cloud-native services tackles the fundamental scalability issues prevalent in conventional HPC configurations. Participants will acquire strategies for transitioning workloads to the cloud, maintaining HPC's stature as a formidable resource for advanced data processing in the era of cloud computing.
Key Takeaways:
This presentation will delve into the strategic incorporation of “knobs” - mechanisms that allow for the adjustment of scalability parameters in response to evolving demands. Through case studies and theoretical models, attendees will learn how to seamlessly integrate these scalability mechanisms within a cloud-native framework, preparing systems for both current needs and future growth. Targeted at architects, this talk provides a deep dive into the role of modular architecture in cloud environments. It offers actionable insights for creating scalable, resilient solutions that remain agile in the face of changing technological landscapes and operational demands.
Key Takeaways:
We'll never be able to understand a software system from a single snapshot of the code. Instead we need to understand how the code evolved and how the people who work on it are organized. We also need strategies for finding bottlenecks and technical debt impairing our productivity, as well as uncovering hidden dependencies between code and people. Where do you find such strategies if not within the field of criminal psychology?
This workshop starts with a crash course in offender profiling before we quickly move on to adopt those principles to software development. 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.
Key insights include:
Prioritizing Technical Debt: Techniques to identify and address technical debt in large-scale systems based on return on investment.
Balancing Improvements and Features: Strategies for deciding between improving existing code versus adding new features.
Mitigating Key Person Dependencies: Methods to identify and reduce risks associated with critical dependencies on key individuals.
During the 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. No coding experience is necessary.
As AI accelerates the pace of coding, organizations will have a hard time keeping up; acceleration isn't useful if it's driving our projects straight into a brick wall of technical debt. This presentation explores the consequences of AI-assisted coding, weighing its potential to improve productivity against the risks of deteriorating code quality.
Adam delivers a fact-based examination of the short and long-term implications of using AI assistants in software development. Drawing from extensive research analyzing over 100,000 AI-driven refactorings in real-world codebases, we scrutinize the claims made by contemporary AI tools, demonstrating that increased coding speed does not necessarily equate to true productivity. Additionally, we also look at the correctness of AI generated code, a concern for many organizations today due to the error-prone nature of current AI tools.
Finally, the talk offers strategies for succeeding with AI-assisted coding. This includes introducing a set of automated guardrails that act as feedback loops, ensuring your codebase remains maintainable even after adopting AI-assisted coding.
Key insights include:
Novel Quality Metrics: Introduction and application of innovative metrics designed to act as guardrails, ensuring that AI contributions maintain high standards of code quality.
Balancing Speed and Quality: Strategies to leverage AI for increased efficiency while avoiding the pitfalls of technical debt.
Real-World Data: Fact-based presentation from comprehensive research on real-world codebases.
“What you must learn is that these rules are no different than the rules of a computer system. Some of them can be bent. Others can be broken. "
-Morpheus
The world of technology seems logical, objective, and to operate by consistent rules. Reality can be illogical, subjective, and even random at times. Yet we accept subjective reality as-is; our single perspective is all we can really know.
In the end, reality constrains engineers and magicians reshape reality. Perhaps reality is not what it seems.
Join Michael Carducci, magician and software architect, as he takes you on a journey through the marriage of the logical and the illogical, the intersection of magic and technology. Discover what each has to teach the other, and how you can apply the lessons to transform your skills and your career.
With over 25 years of experience in both fields–and a lifetime of successes and failures–Michael shares his deeply reflective, unique, and authentically honest perspective on both careers, dealing with problems, challenges, wins, and losses.
This talk combines illusion, engineering wisdom, life lessons, and the stories that connect them. You'll be astonished, engaged, and leave with an entirely new perspective on technology and life.
Somewhere between the positions of “AI is going to change everything” and “AI is currently an overhyped means of propping up silicon valley unicorn valuations” lives a useful reality: AI research is producing tools that can be exploited safely, meaningfully, and responsibly. They can save you money, speed up delivery, and create
new opportunities that might not otherwise exist. The trick is understanding what they can do well and what is a big, red flag.
In this talk I will lay out a framework for considering a range of technologies that fall under the umbrella of AI and highlight the costs, benefits, and risks to help you make better choices about what to pursue and what to avoid.
There is plenty of discussion about how machine learning will be applied to cybersecurity initiatives, but there is precious little conversation about the actual vulnerabilities of these systems themselves. Fortunately, there are a handful of research groups doing the work to assess the threats we face in systematizing datadriven systems. In this session, I will introduce to the main concerns and how you can start to think about protecting against them.
We will mostly focus on the research findings of the Berryville Institute of Machine Learning. They have conducted a survey of the literature and have identified a taxonomy of the most common kinds of attacks including:
This will be a securityfocused discussion. Only basic understanding of machine learning will be required.
Designing a distributed system architecture can be a daunting task, with contradictory requirements and constraints constantly at play. The CAP theorem that directly states the challenges in distributed data stores presents a classic example where developers must choose between consistency, availability, and partition tolerance. The same applies to streaming infrastructure systems, where optimizing for one aspect can come at the cost of another. With cost, throughput, accuracy, and latency as the main constraints for streaming systems, it's crucial to make informed decisions that align with your business goals.
In this session, you'll gain valuable insights into how your system design choices impact your system overall capabilities. You'll also learn about the differences between Flink Streaming and Spark Streaming, both conceptually and in practice. Lastly, you'll understand how combining multiple solutions can be beneficial for your team and business. Join to learn more about the cumbersome world of distributed stream processing systems.
We have seen how Retrieval Augmented Generation (RAG) systems can help prop up Large Language Models (LLMs) to avoid some of their worst tendencies. But that is just the beginning. The cutting edge stateoftheart systems are Multimodal and Agentic, involving additional models, tools, and reusable agents to break problems down in separate pieces, transform and aggregate the results, and validate the results before returning them to the user.
Come get introduced to some of the latest and greatest techniques for maximizing the value of your LLMbased systems while minimizing the risk.
We will cover:
We have seen how Retrieval Augmented Generation (RAG) systems can help prop up Large Language Models (LLMs) to avoid some of their worst tendencies. But that is just the beginning. The cutting edge stateoftheart systems are Multimodal and Agentic, involving additional models, tools, and reusable agents to break problems down in separate pieces, transform and aggregate the results, and validate the results before returning them to the user.
Come get introduced to some of the latest and greatest techniques for maximizing the value of your LLMbased systems while minimizing the risk.
We will cover:
Large Language Models (LLMs) such as ChatGPT and Llama have impressed us with what they can do. They have also horrified us with what they actually do when they are employed with no protection: hallucinations, stale knowledge bases, no conceptual basis for reasoning, and a capacity for toxic and inappropriate content generation. Rather than avoid them altogether or risk legal liability or brand damage, we can put some guardrails around them to benefit from their best traits without fearing their worst.
Retrieval Augmented Generation (RAG) systems augment the process to make it behave more to our liking. Come hear what you can do to benefit from AI systems without fearing them.
We will cover examples using LangChain and LlamaIndex, two open source frameworks for working with LLMs and creating RAG infrastructure.
We will cover:
Introduction to LLMs
Risks and Limitations
Basic RAG Systems
Embeddings
Vector Databases
Prompt Engineering
Testing and Validating LLMs and RAG Systems
Advanced Techniques
AI as Judge
Large Language Models (LLMs) such as ChatGPT and Llama have impressed us with what they can do. They have also horrified us with what they actually do when they are employed with no protection: hallucinations, stale knowledge bases, no conceptual basis for reasoning, and a capacity for toxic and inappropriate content generation. Rather than avoid them altogether or risk legal liability or brand damage, we can put some guardrails around them to benefit from their best traits without fearing their worst.
Retrieval Augmented Generation (RAG) systems augment the process to make it behave more to our liking. Come hear what you can do to benefit from AI systems without fearing them.
We will cover examples using LangChain and LlamaIndex, two open source frameworks for working with LLMs and creating RAG infrastructure.
We will cover:
Introduction to LLMs
Risks and Limitations
Basic RAG Systems
Embeddings
Vector Databases
Prompt Engineering
Testing and Validating LLMs and RAG Systems
Advanced Techniques
AI as Judge
Software keeps moving—and so must we. From end-of-life frameworks to sprawling polyglot stacks and never-ending CVEs, modernizing code at scale is one of the toughest, most necessary problems in engineering today. In this keynote, we’ll take a clear-eyed look at where we are—and what it really takes to move forward.
We’ll unpack the rise of agentic AI, and why the future isn’t just about bigger models but better data and tools. Generative AI may be great at writing new code, but modernizing existing code? That takes precision—and deterministic systems that know when not to guess.
We’ll also dig into the language engineering problem: how do you unify modernization with codebases written in Java, C#, Python, JavaScript, and more? Each language needs a custom model that captures types, formatting, and structure for meaningful, accurate change at scale.
Finally, we’ll confront the security tradeoffs facing modern teams: should you upgrade fast to stay on the latest most secure versions, or leverage back patches to stay secure on what you know? The answer isn't always forward motion—it’s smarter, safer modernization.
We're helping teams navigate all of this with confidence at Moderne, providing AI-driven, multi-language refactoring and modernization at scale. After all, modern software demands more than speed—it demands the ability to evolve, safely and continuously, no matter how complex the codebase or how fast the industry moves.
Join us as we kick off Code Remix Summit—your front-row seat to the future of code.
Generative AI can be a powerful force multiplier for developers, but it also comes with limitations. Developers are expected to co-create with AI, and check the generated output, or risk hallucinations running wild. This can aid development at a local machine, but what happens when you try to apply these tools on a massive scale?
For mass-scale code operations, AI needs to have agency, able to operate with some degree of autonomy. In this session, we’ll cover how you can combine retrieval and tool calling techniques, the richest code data source for Java called the Lossless Semantic Tree (LST), and OpenRewrite rules-based recipes to drive more efficient and accurate AI model output for refactoring and analyzing large codebases.
You’ll learn about how you can use AI embeddings as a powerful tool to visualize, analyze, and even do smarter sampling for your codebase. Plus, we’ll show you how to leverage GenAI to accelerate writing OpenRewrite deterministic recipes.
We’ll take an honest look back and a look ahead on our process, to show you how enterprises can now reliably leverage AI for code modernization at scale.
Architecture documentation is crucial for comprehending requirements, steering design, validating implementation, and maintaining solutions. Unfortunately, it is often overlooked, either tackled at the beginning or pushed to the end of a project cycle. Consequently, the documentation quickly becomes outdated, making it ineffective when extending a solution or resolving a production incident. This session offers guidance on creating and maintaining architecture documentation that remains current and useful.
This session explores various practices and activities for creating and maintaining architecture documentation throughout the Software Development Life Cycle (SDLC) and beyond. Topics include utilizing views and viewpoints, developing conceptual or candidate architectures, setting up an architecture review process, and logging architecture decisions. Prezi Presentation
How adaptable is your technology stack to changes in business requirements, technological advancements, and the availability of new and better tools? When you can more easily secure, upgrade, move, or modernize your code, that means you can adapt quickly and efficiently to changes in technology and markets. That’s what Migration Engineering is all about, which we’ll be exploring in this workshop.
We’ll discuss and demonstrate how to write custom recipes using OpenRewrite, an open source auto-refactoring tool that enables large-scale code analysis and transformations for your teams. You’ll learn the make-up of recipes as we walk through a number of examples, then we’ll demonstrate how to write custom recipes using OpenRewrite. We will assemble these recipes with the visitor pattern, and show how to stitch recipes together with YAML, with Refaster-style templates, with Semgrep matchers, etc. We’ll also show how Generative AI can be applied to accelerate recipe development.
This is a comprehensive look at all kinds of recipe development that will enable you to come away fully equipped to plan and exercise large-scale code transformations in your organization.
Outline
What is Migration Engineering? (15 minutes)
Introducing OpenRewrite (30 minutes)
From source code as text to the Lossless Semantic Tree
How the OpenRewrite community is organized
Recipe Exercise #1: change all integer literals to 42 (because 42 is the answer to life, the universe, and everything) (30 minutes)
Recipe Exercise #2: fixing SAST issues with Refaster-style templates (30 minutes)
Recipe Exercise #3: finding and securing Personally Identifiable Information (1 hour)
Introducing search markers
Introducing Data Tables for impact analysis
Securing endpoints that expose PII
Recipe Exercise #4: finding and fixing SQL injection (1 hour)
Using OpenRewrite’s support for Semgrep-style local data flow analysis
Contributing a security recipe to the open source catalog of OWASP Top Ten recipes
Mass remediation: using our first recipes to issue pull requests or commits to many repositories at once (15 minutes)
Visualization #1: Visualizing the distribution of Gradle versions in a codebase (30 minutes)
Connecting Jupyter Notebooks to OpenRewrite Data Tables
Building a simple bar chart of Gradle version distribution across hundreds of repositories.
Visualization #2: Visualizing unused binary dependencies in Maven and Gradle projects (30 minutes)
Use of network analysis tools in Jupyter for visualizing large scale directed graphs
Where to integrate Migration Engineering into the SDLC (15 minutes)
Open recipe development lab (1.5 hours)
How adaptable is your technology stack to changes in business requirements, technological advancements, and the availability of new and better tools? When you can more easily secure, upgrade, move, or modernize your code, that means you can adapt quickly and efficiently to changes in technology and markets. That’s what Migration Engineering is all about, which we’ll be exploring in this workshop.
We’ll discuss and demonstrate how to write custom recipes using OpenRewrite, an open source auto-refactoring tool that enables large-scale code analysis and transformations for your teams. You’ll learn the make-up of recipes as we walk through a number of examples, then we’ll demonstrate how to write custom recipes using OpenRewrite. We will assemble these recipes with the visitor pattern, and show how to stitch recipes together with YAML, with Refaster-style templates, with Semgrep matchers, etc. We’ll also show how Generative AI can be applied to accelerate recipe development.
This is a comprehensive look at all kinds of recipe development that will enable you to come away fully equipped to plan and exercise large-scale code transformations in your organization.
Outline
What is Migration Engineering? (15 minutes)
Introducing OpenRewrite (30 minutes)
From source code as text to the Lossless Semantic Tree
How the OpenRewrite community is organized
Recipe Exercise #1: change all integer literals to 42 (because 42 is the answer to life, the universe, and everything) (30 minutes)
Recipe Exercise #2: fixing SAST issues with Refaster-style templates (30 minutes)
Recipe Exercise #3: finding and securing Personally Identifiable Information (1 hour)
Introducing search markers
Introducing Data Tables for impact analysis
Securing endpoints that expose PII
Recipe Exercise #4: finding and fixing SQL injection (1 hour)
Using OpenRewrite’s support for Semgrep-style local data flow analysis
Contributing a security recipe to the open source catalog of OWASP Top Ten recipes
Mass remediation: using our first recipes to issue pull requests or commits to many repositories at once (15 minutes)
Visualization #1: Visualizing the distribution of Gradle versions in a codebase (30 minutes)
Connecting Jupyter Notebooks to OpenRewrite Data Tables
Building a simple bar chart of Gradle version distribution across hundreds of repositories.
Visualization #2: Visualizing unused binary dependencies in Maven and Gradle projects (30 minutes)
Use of network analysis tools in Jupyter for visualizing large scale directed graphs
Where to integrate Migration Engineering into the SDLC (15 minutes)
Open recipe development lab (1.5 hours)
Agile has become an overused and overloaded buzzword, let's go back to first principles. Agile is the 12 principles. Agile is founded on fast feedback and embraces change. Agile is about making the right decisions at the right time while constantly learning and growing.
Architecture, on the other hand, seems to be the opposite. Once famously described by Grady Booch as “the stuff that's hard to change” there is overwhelming pressure to get architecture “right” early on as the ultimate necessary rework will be costly at best, and fatal at worst. But too much complexity, too early, can be just as costly or fatal. A truly practical approach to agile architecture is long overdue.
This session introduces a new approach to architecture that enables true agility and unprecedented evolvability in the architectures we design and build. Whether you are a already a seasoned architect, or are simply beginning that path, this session will fundamentally change the way you think about and approach software architecture.
Software architecture involves inherent trade-offs. Some of these trade-offs are clear, such as performance versus security or availability versus consistency, while others are more subtle, like resiliency versus affordability. This presentation will discuss various architectural trade-offs and strategies for managing them.
The role of a technical lead or software architect is to design software that fulfills the stakeholders' vision. However, as the design progresses, conflicting requirements often arise, affecting the candidate architecture. Resolving these conflicts typically involves making architectural trade-offs (e.g. service granularity vs maintainability). Additionally, with time-to-market pressures and the need to do more with less, adopting comprehensive frameworks like TOGAF or lengthy processes like ATAM may not be feasible. Therefore, it is crucial to deeply understand these architectural trade-offs and employ lightweight resolution techniques. Prezi Presentation
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.
This presentation teaches you how to strategically introduce technology innovations by applying specific change patterns to groups and individuals. By using these patterns and techniques, you'll not only benefit your organization but also enhance your career as a technologist, making you a more effective influencer, writer, and speaker.
The swift pace of technological innovation has allowed many organizations to significantly boost productivity while reducing their overall headcount. However, the fluctuating global economy and “change fatigue” within organizations have fostered a risk-averse culture. In such an environment, how can one introduce and integrate the latest technology or processes? The key lies in having a solid understanding of Diffusion Theory and leveraging Patterns of Change.Prezi Presentation
Event-driven architecture (EDA) is a design principle in which the flow of a system’s operations is driven by the occurrence of events instead of direct communication between services or components. There are many reasons why EDA is a standard architecture for many moderate to large companies. It offers a history of events with the ability to rewind the ability to perform real-time data processing in a scalable and fault-tolerant way. It provides real-time extract-transform-load (ETL) capabilities to have near-instantaneous processing. EDA can be used with microservice architectures as the communication channel or any other architecture.
In this workshop, we will discuss the prevalent principles regarding EDA, and you will gain hands-on experience performing and running standard techniques.
If you are getting tired of the appearance of new types of databases… too bad. We are increasingly relying on a variety of data storage and retrieval systems for specific purposes. Data does not have a single shape and indexing strategies that work for one are not necessarily good fits for others. So after hierarchical, relational, object, graph, columnoriented, document, temporal, appendonly, and everything else, get ready for Vector Databases to assist in the systematization of machine learning systems.
This will be an overview of the benefits of vectors databases as well as an introduction to the major players.
We will focus on open source versus commercial players, hosted versus local deployments, and the attempts to add vector search capabilities to existing storage systems.
We will cover:
If you are getting tired of the appearance of new types of databases… too bad. We are increasingly relying on a variety of data storage and retrieval systems for specific purposes. Data does not have a single shape and indexing strategies that work for one are not necessarily good fits for others. So after hierarchical, relational, object, graph, columnoriented, document, temporal, appendonly, and everything else, get ready for Vector Databases to assist in the systematization of machine learning systems.
This will be an overview of the benefits of vectors databases as well as an introduction to the major players.
We will focus on open source versus commercial players, hosted versus local deployments, and the attempts to add vector search capabilities to existing storage systems.
We will cover:
Code quality fails to gain traction at the business level, leading software companies to prioritize new features over maintaining a healthy codebase. This trade-off results in technical debt that consumes up to 40% of developers' time, causing stress, frustration, and costly delays in product delivery. Despite its importance, it's hard to build a business case for code quality: how do we quantify and communicate the benefits to non-technical stakeholders? Or even inside our own engineering team?
In this mini-keynote, Adam presents groundbreaking industry benchmarks and innovative metrics that, for the first time, enable organizations to compare their performance with top industry players. By leveraging statistical models, he demonstrates how you can predict the business gains of technical improvements in terms of increased development velocity and bug reduction. With these actionable recommendations, your organization can ship software faster and gain a competitive edge.