Schedule List ViewGrid View

An evolutionary architecture supports incremental, guided change across multiple dimensions. Read more.

Eben Hewitt shares technology strategy patterns for creating and communicating a compelling technology strategy based on architecture principles. Some of these frameworks originate in the world of business strategy consulting and some are hard-won from Eben's time as a CTO and chief architect. Join in to upgrade your skills from architect to strategist using these proven and innovative patterns. Read more.

Chaos engineering helps you gain trust and confidence in your system of software development and delivery, but it is often misunderstood to be only about breaking things, and worse only about breaking infrastructure. Russ Miles debunks those limitations and demonstrates how chaos engineering can be a full part of your resilience engineering capability. Read more.

Jim Gough shares his experience moving from a traditional monolithic architecture to a single API composed of many microservices, along with some of the challenges it presented. Jim also explores technologies and patterns with a mixture of hands-on examples and discussion topics and considers the impact to team culture and Agile practices required to achieve operational excellence. Read more.

Though you can design microservices to talk to each other synchronously, as if they were making function calls, that's not the best way to do things. Choreographed (asynchronous) systems solve many problems inherent in synchronous (orchestrated) communication. Allen Holub shows you how to build effective choreographed microservice systems. Read more.

Today, your product's success depends on the creation of experiences in a steadily rising number of channels, leading to increasing demands for your content management system. Stefan Judis explains how Contentful’s content infrastructure helps developers on the frontline fetch the data they need, ship modern websites faster, and automate content distribution while using their favorite tools. Read more.

The future of software is being driven by intelligent applications. By the year 2020, more than 85% of customer interactions will be carried out without humans. The road to enterprise intelligence starts with the humans behind the curtain. Kishau Rogers explains how to reduce the friction of AI adoption in the enterprise using systems thinking and people-centered workflows. Read more.

Think of this talk as a Microservices 201. You know microservices basics, but can you successfully maintain them in production? Join Maria Gomez to explore the concept of observability as a way of maintain a healthy production environment. Read more.

Fahran Wallace explores the intersection of programming, architecture, and psychology through the medium of funny-in-retrospect memories, borrowed war stories, and attempts to avoid people swearing at her design choices five years later. Read more.

Launched 10 years ago, the BBC's iPlayer on TV has become the largest iPlayer platform. David Buckhurst and Ross Wilson explore the evolution of the BBC's TV application architecture, from the early days courting different native technologies to the development of an open source library and standards-based platform that supports multiple BBC applications across thousands of TVs. Read more.

If you want to develop high-quality products, you need happy developers and strong feedback loops. Yiannis Kanellopoulos and Evelyn van Kelle discuss the factors that determine developer happiness, explore the crucial relationship between developer happiness and code quality, and explain how to enhance overall code quality through a blend of interpersonal communication and tool-based analysis. Read more.

More and more enterprises are developing modern applications centered on Node.js, but with no de facto reference architectures yet for full stack JavaScript apps, many enterprises are struggling to get repeatable success. Paul Savage shares a warts-and-all dive into modern JavaScript development, covering npm, security, performance, and how projects like Node.js are being maintained. Read more.

Integrating microservices and taming distributed systems is hard. Most people still integrate via REST but are not even aware of missing consistency guarantees in these architectures. Bernd Rücker shares three challenges he's observed in real-life projects and demonstrates how to avoid them, using live coding. Read more.

Dan Haywood explains how he and a tiny one-and-a-bit-pizza team used Apache Isis—an implementation of the naked objects architectural pattern—to build an invoicing system, Estatio. You'll see what an Apache Isis app looks like in the flesh and learn how Dan and his team manage to keep it modular. Read more.

An Akka expert and a Kubernetes expert walk into a bar. They order drinks and try to figure out which technology is better for building distributed applications. Does Akka clustering have a place in the age of Kubernetes? Does Kubernetes bring any value to those who are building applications using Akka? Adam Sandor and Fabio Tiriticco share research to help answer those questions. Read more.

While there are differences between serverless architecture and microservices architecture, both require an application to be composed of a collection of loosely coupled components. Thus, it is possible to implement microservices architecture as a serverless application. Nikhil Barthwal elaborates, covering the pros and cons, details of various deployment patterns, and best practices. Read more.

And you shall do it only once. Exactly once. That's a very common assumption for most of business software. One trigger equals one outcome. Szymon Pobiega explains why duplicate messages are a fact of life in distributed systems (and why no infrastructure can help you). Fortunately, Szymon also shares tips on how to deal with nasty duplicate zombie messages. Read more.

There are numerous standards and best practices to describe and document APIs, but there's still uncertainty how to best use them to combine API description, documentation, and labeling. Erik Wilde offers an overview of the existing approaches, demonstrates how to use them, and proposes an additional layer on top of which API labeling becomes more unified, and thus more useful. Read more.

Chaos engineering is a discipline that focuses on improving system resilience through controlled experiments that expose the inherent chaos and failure modes in your system. While most of the publicized literature and tools focus on killing EC2 servers, Yan Cui explains how to apply the same principles of chaos to a serverless architecture built around AWS Lambda functions. Read more.

Building microservice architectures is complex. Handling the involved complexities is usually left up to the development teams to implement. Using open source components to address these challenges is an option, but this quickly leads to excessive library bloat in your microservices. So let's put them on a diet—with Istio. Join Mario-Leander Reimer to learn how. Read more.

Leemay Nassery explains the importance of data collection pipelines and walks you through efficiently storing various datasets. Join in to learn how to avoid the "pipeline jungle" construct by thinking holistically about the data and the tiers that follow the initial consumption of these events. Read more.

Software architects and enterprise architects work with a variety of roles, and often the deep technical work is performed by other application architects or solutions architects. Maggie Carroll shares useful skills and actionable techniques for creating a new architecture function and leading other architects in developing a system of systems. Read more.

Wenbo Zhu illustrates the key architectural properties and underlying technologies to create and deploy a real-time, stateful application on top of the completely stateless serverless architecture. Read more.

Microservices have quickly become a popular way to develop software systems. But as organizations implement production systems based on microservices, they are recognizing the importance and complexity of securing microservices. Rob Wilson shares techniques for securing microservice APIs and details a practical multiplatform model that you can use for securing your own microservice environments. Read more.

Microservices are all the rage these days. But what practical factors should you consider once you’ve taken the plunge? Marco Palladino provides a working framework of the architectural and organizational decisions senior technologists will need to make in order to solve the right problems for their business. Read more.

Drawing on her experience as a developer in IBM's Cloud Garage, Holly Cummins shares stories of customers struggling to get cloud native and explains how IBM applied its methodology to turn things around. You'll learn the ideal team size, the ideal microservice size, what skills a team needs, the role of architects, how to know if something is ready to ship, and whose fault everything is (joke). Read more.

As people with strong technical backgrounds, we know how to get most out of the tools and devices we use, but this doesn't necessarily guarantee best results on a team. Bulama Yusuf explores proven ways to communicate and connect with a team as a software architect, ensuring that your team is working at its best. Read more.

Dennis Bijlsma and Haiyun Xu explain how to measure the maintainability of software landscapes that consist of many systems communicating with each other—and what that means for the teams working on them. Along the way, they explore a number of trade-offs to consider when designing the landscape and share best practices for modern software landscape architectures. Read more.

Cornelia Davis explains how to use an event-driven approach to address the fallacies of distributed computing in a very different way, offering significant benefits over request-response, and details event-oriented solutions to problems commonly addressed with well-known patterns. Read more.

Serverless doesn’t mean no servers. It’s a metaphor for a new way of building applications. Pratik Patel explains how serverless fits into the world of microservices and examines the pyramid of application development and deployment. You'll then put on your architect hat to look at serverless options and how they impact applications architecture. Read more.

Architectural choices are often driven by nonfunctional requirements like reliability and scalability. Unfortunately, it can be deceptively hard to specify the right requirements. Big decisions made hoping to hit X nines often fail to ensure the nines measure the right thing. Yaniv Aknin shares lessons learned working in this space at Google, helping you focus on metrics that matter. Read more.

We software professionals owe it to our customers (and ourselves) to make good decisions when it comes to picking one technology over another. Nathaniel Schutta details the criteria to consider when comparing technologies, explains how to avoid burning platforms, and details what to do when you've reached a dead end. He then shows you how to apply these techniques to a current technology or two. Read more.

Andrea Dobson-Kock discusses why people behave unethically and what can be done about it, including social psychology research on behavior, ethics and company culture, and anti-patterns to avoid. Read more.

Communicating about architecture to non-IT and business stakeholders is a valuable skill for architects. After all, many architectural decisions are made by others, so they need to be informed with clear, honest, intelligible, and helpful information and advice. Jochem Schulenklopper shares theory and practical tips on eight facets of the visual communication of architecture. Read more.

Microservices is a popular but vague term. Definitions of microservices can vary depending on what you want them to accomplish and how you want them to communicate with each other. Join Mike Amundsen to learn about the three types of microservices, see what makes them unique, and discover when you deploy each of them. Read more.

Here's some sad news: staging is a lie and will never be identical to production, because production is unknowable. But here's the good news: production can contain multitudes, including features you aren’t ready to turn on or activate yet. Join Heidi Waterhouse for an exploration of the ways that you might be able to kill staging and perform better. Read more.

John Jeremiah shares best practices and ideas to help you lead DevOps transformations and accelerate software delivery. Read more.

Vladik Khononov shares his experience using the domain-driven design methodology at Plexop, a large-scale marketing system that spans over a dozen of different business domains, from the management of advertising spaces to sales agents’ commissions. Read more.

Today, your product's success depends on the creation of experiences in a steadily rising number of channels, leading to increasing demands for your content management system. Stefan Judis explains how Contentful’s content infrastructure helps developers on the frontline fetch the data they need, ship modern websites faster, and automate content distribution while using their favorite tools. Read more.

We don't yet have an adequate language for describing serverless architectures. Today, we use informal diagrams in which no precise meaning can be attached to the diagram as a whole or to any particular element. Asher Sterkin explains why this is a problem and what we can do about it. Read more.

Ashley Ward details the security advantages of containers relative to traditional architectures, covering what makes containers more secure, the changing nature of the threat landscape for cloud-native technology, and how the combination of container platforms like OpenShift with purpose-built security solutions lets organizations deliver more secure software faster than ever before. Read more.

Most architectural designs are rejected by stakeholders or teams, in part because they didn't participate in creating the solution. Mlungisi Duma shares useful techniques for involving business expects in architecture design and the software development life cycle. You'll also learn how to convince the IT team to buy in to the new design without too much resistance or friction. Read more.

Distributed systems are not strictly an engineering problem. Tyler Treat looks at distributed systems through the lens of user experience, observing how architecture, design patterns, and business problems all coalesce into UX. Tyler also shares system design anti-patterns and alternative patterns for building reliable and scalable systems with respect to business outcomes. Read more.

Credit card fraudsters are always changing their behavior and developing new tactics. For banks, the damage isn’t just financial; their reputations are on the line. So how do they stay ahead of the crooks? Sarah LeBlanc and Hany Elemary explore a system that utilizes continuous delivery for machine learning to allow for rapid experimentation and the deployment of models to catch these fraudsters. Read more.

One of the most interesting and provocative patterns to face the software architecture community is the idea of using event streaming as a source of truth—a pattern where replayable logs provide both communication and storage, splicing the retentive properties of a database into a system designed to share data across teams. Benjamin Stopford explains why this pattern is transformative. Read more.

With cloud-native and microservices architecture gaining wide adoption, asynchronous programming patterns are becoming increasingly important. Irakli Nadareishvili details three major async forms that are relevant in this space—event sourcing, reactiveness, and data streams—defining each pattern, explaining relevant use cases, and exploring differences in implementation. Read more.

Continuous delivery for 12-factor microservices works by design. When you can architect a solution for continuous delivery, you control all the angles. But what do you do when you don’t have that luxury? Brad Topol explains how modernizing existing IT infrastructure with containers enables you to manage change through continuous delivery and reduce ongoing operational costs. Read more.

Tobias Uldall-Espersen and Thomas Krogsgaard Holme explain how they applied microservice architecture and privacy by design principles to break down a monolithic portal containing 50+ products—the Danish national ehealth portal Sundhed.dk—redesign it, and produce a scalable and flexible platform in compliance with the EU General Data Protection Regulation (GDPR). Read more.

How can Mozilla evolve its products and capabilities to serve the global, human-driven internet of the future? The company is guided by its mission and supported by the capabilities of its staff and community. Michael Van Kleeck dives into how Mozilla uses its version of enterprise architecture to wisely explore, evaluate, and pivot to and from future opportunities. Read more.

Microservices provide a way to break up a monolithic architecture into multiple atomic units, allowing an independent scalability of a service. They also provide a better way to divide the domains across multiple teams. Luca Mezzalira explains how to apply the same principles to frontend applications, enabling you to scale up a project with tens of developers without reducing the throughput. Read more.

The architectural principle of CQRS makes great promises about the scalability of applications. Allard Buijze and Nakul Mishra elaborate on these promises and explain how to bring them into practice. Along the way, they provide insight into the challenges Casumo faced while scaling from thousands to billions of events and how they were resolved. Read more.

Danske Bank is implementing ideas and practices such as CI/CD, microservices, and DevOps within the extreme conditions of a financial enterprise. Angelo Agatino Nicolosi explains how the bank is defining and delivering brand-new financial services at startup speed through the simple concept of an enclave. Read more.

Fender Digital’s service infrastructure is 100% serverless. The promises of serverless include reduced costs and simplified operations; the challenge lies in how to implement complex applications on a FaaS platform. Michael Garski shares best practices Fender Digital has established to optimize function performance and ensure observability. Read more.

We developers and architects are a major force influencing software, technology, and the world it creates. If we really want to create a better world, we need to open our eyes to the link between ethics and software. Rotem Hermon discusses ethical challenges related to technology, sense of self, politics, and truth and explains what we can do about it. Read more.

CNN recently rated software architect the number one job in America. Yet no clear path exists for moving from developer to architect. Neal Ford blends lecture and hands-on real-world group exercises to explore the many aspects of software architecture. You'll learn various integration styles (and when to use them) as well as patterns to fit various business needs and requirements. Read more.

Confronting the cloud can feel quite daunting. Matt Stine teaches you how to create cloud-native architectures by applying a rich catalog of patterns that you'll be able to leverage regardless of your choice of cloud provider or technology stack, focusing on six key architecture qualities: modularity, observability, deployability, testablity, disposability, and replaceability. Read more.

Enterprises need to deliver better software faster. The microservice architecture has the testability and deployability necessary for DevOps. Chris Richardson walks you through using the microservice architecture to develop your applications, exploring key obstacles you'll face (and how to deal with them) and sharing strategies for refactoring a monolith to a microservice architecture. Read more.

Communication is not an optional soft skill for architects. It's essential to your success. You may have the most brilliant ideas, but if you're ineffective in communicating their value or if you can't obtain buy-in from your stakeholders, you won't be successful. Seth Dobbs shares a process for effectively shaping and communicating your solutions to different stakeholders. Read more.

With systems like Travis CI, Circle CI, and CodeBuild, we're never more than a few lines of YAML away from a complete continuous delivery pipeline. However, ephemeral build systems constantly recreate the world from scratch, increasing build time and lengthening the CD feedback loop. John Chapin addresses those challenges and shares a reference pipeline using AWS CodePipeline and CodeBuild. Read more.

A web API is a channel into your business domain. Because of its simplicity, REST is the de facto standard for developing web APIs, but translating complex domain behavior to simple REST concepts is typically not straightforward. Tom Hofte and Marco van der Linden explore RESTful resource modeling and share practical solutions to bridge the gap between a domain model and a RESTful API. Read more.

If you still use large up-front design, you'll likely encounter problems during implementation. The solution is to build around a domain-focused metaphor that allows for incremental changes while maintaining coherence throughout. Join expert Allen Holub to learn how to develop an effective, incremental architecture that you can easily modify as new requirements emerge. Read more.

Event-driven programming has been proven useful in many situations. However, the asynchronous programming model often needs some time to get used to. Marco Emrich explores event concepts in a familiar language and walks you through solving an exciting kata with the help of event-driven programming. Read more.

A RESTful approach to microservices offers a number of benefits. Mike Amundsen walks you through building adaptable microservices that take advantage of the features of REST, including statelessness, self-description, and using hypermedia to discover and modify application state. Read more.

Join Nick Tune and Zsófia Herendi to learn how to model a complex system and break it down into cohesive bounded contexts. You'll leave with skills you can immediately begin applying in your organization to improve the autonomy of your software services and the teams that build and run them. Read more.