Daniel Krook explores Apache OpenWhisk on IBM Bluemix, which provides a powerful and flexible environment for deploying cloud-native applications driven by data, message, and API call events.
Kai Wähner shares 10 lessons learned from building cloud-native microservices in the middleware world, including the concepts behind cloud native, choosing the right cloud platform, and when not to build microservices at all, and shows how to apply these lessons to real-world projects by leveraging Docker, CloudFoundry, and Kubernetes to realize cloud-native middleware microservices.
The latest buzzword is "serverless"—the idea of replacing your server applications with. . .well, what, exactly? Mike Roberts introduces the concepts behind serverless architectures to answer this question.
Regardless of the techniques used to make an enterprise solution highly available (HA), failure at some point is inevitable. Resiliency is how fast a system reacts and then recovers to such failures. Jeremy Deane covers a number of techniques and patterns for addressing architectural resiliency, including intelligent agents, tolerant reader, and circuit breaker.
Michael Nygard demonstrates how to design and architect systems that admit change—bending and flexing through time. Using a blend of information architecture, technical architecture, and some process change, Michael walks you through examples of rigid systems to show how to transform them into more maneuverable architecture.
Karun Japhet tells a tale of bridging the technological divide between modern event-sourced systems and more traditional architectures from the last few decades, exploring how a resilient, modern, event-sourced, CQRS-based, domain-driven designed platform can be built with eventual consistency guarantees when third parties provide no guarantees of reasonable service.
Akka, the distributed systems toolkit, has been pushing the envelope of distributed and reactive systems for many years now. Konrad Malawski and Henrik Engström walk you through writing services using state-of-the-art technology like Akka Cluster and Streams and expose them as microservices using Akka HTTP, Play, or Lagom.
Jochem Schulenklopper and Hans-Jürgen Jacobs demonstrate how to (visually) communicate architecture to non-IT stakeholders, sharing relevant theories, techniques, and examples for creating architecture visualizations that are attractive, informative, and easier to understand. You'll then apply your newly gained knowledge in an interactive, small-group workshop with a prepared case.
Bridget Kromhout compares the architectural patterns of modern distributed systems with the communication patterns of successful teams, explaining how to apply the principles and practices of a DevOps culture to ensure we build systems designed for humans.
Most applications should at least consider running in multiple data centers for reasons from end-user latency to being able to meet the modern expectation for 24/7 uptime. Jeff Poole outlines the considerations when moving to multiple data centers and the trade-offs for different approaches.
Many organizations are moving toward a distributed system architecture like command query responsibility segregation (CQRS) and event sourcing. Maria Gomez and Stacey Watro discuss the challenges of deploying and supporting these systems in production and explore different strategies to mitigate these challenges, such as building resilient systems and monitoring.
Modern web and mobile applications have read/write ratios that are far different than when many of the underlying technologies and architectural patterns were first developed. Seth Dobbs demonstrates architecting data partitioning and flow control to enable our highly consumption-oriented world.
How does a small engineering team decide which technologies to use? Or whether to be open source or not? To be self-hosted or in the cloud? Wes Chow discusses the choices Chartbeat has made, how they’ve succeeded and failed, and the framework by which the company makes decisions and argues for transparency and empathy from free and proprietary technologists to ease the pain.
What is a microservice? What do you mean when you say service discovery? How does a circuit breaker work? These questions (and many more like them) are rapidly circulating within our industry, and we're struggling to answer them well. You'll rediscover the value of pattern languages as Matt Stine explains how they can help us make sense of the ongoing paradigm shift in software architecture.
Hybrid and multicloud deployments are critical approaches for bridging the gap between legacy and modern architectures. Sandeep Parikh discusses common patterns for creating scalable cross-environment deployments using Kubernetes and explores best practices and repeatable patterns for leveraging Kubernetes as a consistent abstraction layer across multiple environments.
Security starts and ends with architects. Designers of systems have the responsibility to ensure that security is built in. Aaron Bedra walks you through the security skills you need as a system designer and architect, identifying common gaps and misconceptions and sharing resources to help you improve your security architecture knowledge.
Software architecture and architects focus on engineering, business, and the user—the developer experience is usually an afterthought, which impacts the quality of the system being built. Bulama Yusuf discusses the importance of the developer experience and why it is important that the people who are going to build the system be taken into consideration right from the start.
Topologies are the basic abstraction of distributed systems. Historically, changing topologies required re-architecture. Today, microservices enable any engineer to dynamically change topologies of business logic. Rafael Schloming explores the power of topologies and common topological patterns and demonstrates how a microservices architecture lets us dynamically create and update topologies.
Microservices offer advantages but also come with associated costs. Modularizing applications without going the full microservices route is a viable alternative that is often overlooked. Sander Mak helps you ask the right questions in order to make good decisions for the right reasons.
Machine-learning systems can be designed to be just as reactive as the most bulletproof web or mobile app. It takes a system-level understanding of your machine-learning system and a team-level commitment to continual evolution. But you can succeed. Jeffrey Smith shows you how.
Nancy Nunes demonstrates how to construct versatile software components that can be deployed on multiple platforms without performance hits normally associated with generalized behavior. You’ll leave with understanding and an operational example of how to package software components to make them adaptable to running in a single processor or distributed processing system.
In few years, Wix grew from a small startup with traditional system architecture (based on a monolithic server) to a company that serves 100 million users. Aviran Mordo explains how Wix evolved from a monolithic system to microservices, using some interesting patterns like CQRS to build a blazing-fast, highly scalable, and highly available system.
Stanley Black and Decker's Digital Accelerator has spent the last year migrating existing applications, and creating new ones, using serverless architecture on AWS. Christopher Phillips explores the pros and cons of going serverless, as well as the tools and patterns you need and the caveats learned along the way.
Mike Roberts expands on the ideas from his Introduction to Serverless keynote to give a cautiously optimistic description of the state of the art of the serverless world, concluding with how it’s expected to develop over the coming months and years.
Distributing website content in a microservices-driven architecture is not a trivial task, and it requires solving complex problems stemming from the large number of servers involved and the variety of edge cases that need to be solved. Georgiana Gligor shares a solution to content snapshotting, distribution, and caching in a silo-based architecture involving tens of machines.
Continuous delivery is gaining recognition as a best practice, yet adopting and iteratively improving it is challenging. Lyndsay Prewer shares various best practices for doing continuous delivery well, drawn from his experiences working with two very different organizations—one with a .Net monolith architecture, the other with a microservice architecture of over 300 Scala microservices.
Adam Tornhill introduces novel techniques to uncover both problematic code and the social dimension of the teams that build your software. This combination lets you prioritize the parts of your system that benefit the most from improvements, detect organizational issues, and make practical decisions guided by data.
Dion Stewart offers an overview of user story mapping—a technique for improving product delivery by keeping development focused on users—using annotating user journeys, which help architects design elegant systems by ensuring the needs of the user experience are met and using the user experience to inform architectural decisions.
"Stream" is a buzzword for several things that share the idea of timely handling of neverending data. Big data architectures are evolving to be stream oriented. Microservice architectures are inherently message driven. Dean Wampler defines "stream" based on characteristics for such systems, using specific tools as examples, and argues that big data and microservices architectures are converging.
These days one of the hardest problems in software is software. Code to run our code, code to change our code, code to see into what our code is doing—all determining how our components run and talk to each other. Jessica Kerr explores those powerful architects below that we call infrastructure engineers.
Mark Richards discusses the evolution of software architecture and shows how the systems we've built so far won’t live up to current social, economic, and technology demands.
Domain-driven design (DDD) helps focus and guide software development efforts, but learning DDD can be a daunting task. Steven Lowe shares three simple philosophical rules that guide understanding and application of DDD—capture the domain model, embed it in the code, and protect it from corruption—and explains how these rules guide DDD at all scales.