Are you vigilantly keeping watch on your system in anticipation of altering some setting or system state? When parts of your system fail, do you perform manual cleanup? If so, humans have been injected into your architecture. Michelle Brush explores the factors that lead to systems that run on human intervention and shares best practices for detecting and removing humans from the machine.
Hadoop-based data platforms that power ETL jobs and machine learning pipelines are great examples of monolithic architectures that could be redesigned with microservices. Stepan Pushkarev walks you through building and deploying data processing, reporting services, training, and prediction pipelines as decoupled microservices connected with the rest of the enterprise architecture.
Driven by the need for data analytics in Industry 4.0, edge computing is gaining momentum to bring intelligence to the devices at the network’s edge. Fei Li offers insights on a microservice-based architecture that keeps analytics applications on edge devices while dynamically utilizing resources on the cloud to achieve resilience and scalability in critical industrial applications.
Nathaniel Schutta explains why an architect's job is to be a storyteller. Architects are essentially the Rosetta Stone of an organization, providing translation services (or, as some would call it, the "elevator" between the executive suite and the development floors). The challenge lies in not only crafting a compelling message but doing so for wildly disparate audiences.
Architects are increasingly becoming convinced that the cloud is the way to scale. The most important consideration after deciding on a cloud migration is the architectural design of the proposed infrastructure. Ann Mwangi shares considerations when deciding on and designing a cloud architecture for a business and highlights common pitfalls that teams fall into during this process.
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.
IoT device management and multiprotocol messaging platforms demand specific architectural decisions and high-concurrency approaches due to the massive number of expected devices. Drasko Draskovic and Janko Isidorovic share an architecture, implementation, and testing procedures needed to create an industry-grade IoT platform based on microservices and Docker containers.
When discussing architecture, things like microservices and the Reactive Manifesto come to mind. However, the culmination and success of technical choices is strongly determined by social context. Evelyn van Kelle and Pepijin van de Kamp explore the interplay of technical issues and the social aspects of working on a team, such as communication and shared understanding of assumptions and choices.
In many cases, existing architectures represent an accident of circumstances. James Thompson explains why you should move beyond the accidental and introduce intentional architectural thinking to your team, outlining the benefits of deliberate software architecture, from helping newer engineers understand why certain boundaries exist to enabling senior engineers to improve their skills and more.
Monolithic applications often resist the introduction of clearer architectural boundaries. Drawing on a real-world project as an example, James Thompson explains how to implement bounded contexts into such applications in conjunction with normal feature development and maintenance.
Microsoft finally has a truly open source, cross-platform development framework that is ideal for building cloud-native microservices: ASP.NET Core. Kevin Hoffman explains how to use ASP.NET Core to build immutable releases with Docker, address real-world concerns like configuration, security, and data access, and implement continuous integration and continuous delivery in the cloud.
As Expedia refactors its backend services into a finer-grained microservice architecture, frontend applications have begun to be split into smaller applications serving a small number of pages or content on the website. Rick Fast details how Expedia is creating an extremely configurable, self-service edge architecture for routing between frontend applications and managing bot traffic.
In distributed systems, some business transactions and end-to-end processes stretch across the boundaries of individual services. While event-driven choreography leads to nicely decoupled systems, complex event chains can cause headaches. Bernd Rücker and Martin Schimak explain why transforming certain events into commands is beneficial and how to avoid losing sight of larger-scale flows.
Nils Magnus (LinuxTag Association and Open Telekom Cloud)
Nils Magnus outlines the 12 stages of self-awareness that lead to ultimate container enlightenment. It's a long and winding road: while usual suspects like system engineers, developers, and system designers understand container virtualization fairly well, its architectural pattern remains a different cup of tea, and orchestration frameworks and auxiliary tools make it hard to see to the bottom.
In the last five years, data has again risen to prominence, with chief data officers, data science, and analytics on the business side and microservices and NoSQL databases on the technology side. But how should software architects approach data in this age of Agile, big data, and the cloud? Murat Erder looks into key trends and architectural considerations.
It's evident that modern software architecture is evolving toward fully component-based architectures, but there are many challenges to delivering such applications in a continuous, safe, and rapid fashion. Daniel Bryant shares a series of patterns to help you identify and implement solutions for continuous delivery of contemporary service-based architectures.
Microservices are an increasingly popular approach to building cloud-native applications, and dozens of new technologies that streamline microservices development, such as Docker, Kubernetes, and Envoy, have been released over the past few years. Phil Lombardi and Rafael Schloming walk you through actually using these technologies to develop, deploy, and run microservices.
Whether you are migrating existing applications or starting afresh with microservices, Clarence Bakirtzidis helps you get started on your journey to Docker-based production environments, focusing on an infrastructure-as-code approach via scripting and automation from the command-line interface.
After years of personal data breaches and mishandled payment data, lawmakers are waking up to the importance of online privacy. Eleanor McHugh explains why, to comply with new laws, we need to put privacy at the heart of our design processes. But how do we do this when design itself is often seen as the enemy?
Reactive programming is quickly becoming one of the hottest topics in frontend development. Luca Mezzalira offers an overview of available reactive architectures for frontend ecosystems and evaluates libraries and frameworks, such as Cycle.js, MobX, and SAM, that you can use to make your current architecture reactive.
Aligning organizational and technical boundaries will be the most important responsibility of future architects. Nick Tune explains why we must learn to codesign and coevolve teams and technical architectures to take the next big step to reduce lead times and build learning organizations.
A successful software system requires both a strong software architecture and a great user experience (UX). However, UX is surprisingly often neglected by software architects. Using Google Maps as an example, Matthias Naab and Marcus Trapp explore the architectural decisions behind excellent UX and the relationship between UX designers and software architects.
Societies work because we follow the rules, but what if those same rules are holding us back? The problem may be because we are failing to change our habits. Dan North introduces some uncomfortable truths from Eliyahu Goldratt, author of The Goal, a cornerstone of modern management theory, that help us recognize and challenge this behavior and unlock the true value from our technology.
Web services are typically stateless entities that need to operate at scale. Nikhil Barthwal explains how Jet.com implemented event-driven microservices architecture using a functional language, demonstrating how the functional paradigm captures the behavior of this service architecture very naturally and offers several benefits, such as scalability, productivity, and correctness.
Think big, act small. It’s easy to develop a vision, but there are often many architecture barriers along the path to achieving it. Asanka Abeysinghe explores iterative architecture—introducing iterative architectural changes to support business and technical requirements—and shares real-world examples.
The persistent memory revolution is almost here, but many of us architects can't clearly picture where persistent memory fits into our applications. The hard truth is that persistent memory isn't quite like memory or storage; it's a new tier with new capabilities and tradeoffs. Rob Dickinson dispels some of the myths about persistent memory so you can better plan your own research.
The retail landscape for brick and mortar companies transitioning to digital is incredibly complex. Saddled with extensive legacy systems that impinge rapid development capabilities, retailers need an architecture that melds the new with the old. Joel Crabb shares a platform architecture for retailers to compete in this new world.
As our world becomes digital, the systems we build must be secure by design. The security community has developed a well-understood set of principles used to build secure systems, but they are rarely explained outside that community. Eoin Woods walks you through these fundamental principles and demonstrates how to apply them to mainstream systems.
Most discussions about implementing microservices start by evaluating the technical options and their challenges. However, the real business value is in functionality. Allard Buijze demonstrates how to build evolutionary microservices, starting with a single application that can be scaled out and distributed once the sensible boundaries are known.
Mike Roberts discusses the benefits, trade-offs, concepts, and patterns of serverless architecture and then demonstrates building a serverless application using AWS technology with API Gateway and Lambda.
Uwe Friedrichsen walks you through the foundations of resilient software design: what it is, why we need it, how to start, and where the biggest pitfalls lie, with a focus on design challenges and useful resilience patterns.
Ben Stopford looks at two forces that sit in opposition: data systems (which focus on exposing data) and services (which focus on encapsulating it). How should we balance these two? Streaming offers a solution.
Karun Japhet tells the tale of how one company bridged the technological divide between modern event-driven systems and traditional architectures, building a resilient platform with eventual consistency guarantees even when third parties provided no guarantees of reasonable service.
AWS Lambda has changed the way we deploy and run software, but the serverless paradigm has created new challenges to old problems around testing, CI/CD, and ops. Yan Cui shares solutions to these challenges, drawing on his experience running Lambda in production.
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.
Hiring and maintaining a software team is a challenging proposition. Programmers are among the toughest craftspeople to manage and assess. To gain a fresh perspective (and relieve the boredom), Don Kelly turns to the pulp fiction of his adolescence for inspiration, explaining how he maps teams from fictional universes into the software teams he would like to build.
What we see in the modern data store world is a race between different approaches to achieve distributed and resilient storage. The IoT, genomics, and applications for any other field also raise the demand for a stateful layer. Max Neunhöffer walks you through the components and the inner workings of modern open source databases like ArangoDB, Cassandra, Cockroach, and RethinkDB.
Software practitioners believe if you can’t reproduce a bug, you can’t know if you’ve fixed it, but sometimes it's just not possible. Issue tracking systems have a special resolution type for this situation—Cannot Reproduce. Michelle Brush highlights principles and practices that deliver reproducibility in systems, arguing that we are getting closer and closer to the death of Cannot Reproduce.
We must rethink how we approach the design and architecture of software for the future. Architectural modularity will be a cornerstone of these software applications. Mark Richards explores the history of architectural modularity, discusses current architecture patterns that support modularity, and explains why architectural modularity is so important (and necessary).
Streaming platforms have emerged as a popular, new trend, but what exactly is a streaming platform? With Apache Kafka at the core, streaming platforms offer an entirely new perspective on managing the flow of data. Neha Narkhede shares examples of Kafka in action and explains why streaming platforms have become the central nervous system for modern digital businesses.
A few years ago, Gamesys began to modernize its platform. Moving to a containerized microservice architecture was a big part of this journey. While the road taken was long and bumpy, the team was able to fulfill most of its promises. Zsolt Sztupák shares Gamesys's experience, pinpointing various design decisions that both helped and hindered the team in achieving what they wanted.
Imagine that tomorrow you started work on a new software system. What would you need to know to be productive? What information would help you orient yourself, make better decisions, and know that you're heading in the right direction? Patrick Kua uses the analogy of the travel guide to help you decide what to document in your software systems.
In a monolith, authorization is easy. In a microservices world, you have to make hard choices about your data model and the abstractions on top of which authorization rules are built. Wilfried Schobeiri and Kasey Klipsch share an approach to implementing distributed authorization in a microservices context, covering fallacies, common pitfalls, and best practices along the way.
Software is the DNA of modern society. However, most organizations don't seem to care about the people who are fundamentally responsible for implementing their digital vision: software developers. Yiannis Kanellopoulos explores several deficiencies SIG found in its current approach to making developers excel and realizing prophesied potential. So how can you help? One word: empowerment.