Mike Amundsen offers 12 patterns and practices for building APIs that can safely evolve over time and client applications that can adapt to those changes without relying on explicit versioning systems or repeated redeployment.
Software architecture is usually seen as a technical challenge (18 million requests per minute), but the real problems are human problems (33 teams). New Relic tackles both aspects by taking lessons from biology to build a resilient architecture that will grow with the company. Brent Miller shares New Relic's approach and explores the costs and benefits of using this kind of strategy.
Stephen Pember offers an introduction to command-query responsibility segregation (CQRS) and event sourcing (ES), techniques that help when working with complex systems with high user demand. Steve explores the individual techniques, discusses their usefulness, and outlines what ThirdChannel has learned after using ES and CQRS for the past year.
Stephen Pember offers an overview of reactive applications and Reactive Streams. Steve explores the individual concepts and examines a sampling of libraries and frameworks available on the JVM for reactive applications. Demo applications and sample apps round out Steve's talk, giving attendees an idea of where to begin with the reactive ecosystem.
Microservices are all the rage, but unfortunately so are security breaches. Sam Newman explains what you can do to have one without the other, exploring the many different ways in which you can secure your fine-grained, distributed architectures.
Although it's a classical approach, multitenancy at the application level comes with limitations in terms of processing isolation, efficient hardware utilization, and advanced per-tenant configuration. Thierry Delprat demonstrates Nuxeo's new container-based approach—powered by dynamic Docker containers, CoreOS, Fleet, and Gogeta—that avoids common issues with traditional multitenancy.
Everyone is talking about microservices, but there is more confusion than ever about what the promise of microservices really means and how to deliver on it. Jonas Bonér explores microservices from first principles, distilling their essence and putting them in their true context: distributed systems.
In this 2-day hands-on workshop, Sam Newman covers both the theory and the practice of microservices. Learn what microservices are all about, then build them yourself.
The world of the IoT is exploding with respect to sensors, and speech and analytics are providing a powerful new user experience. David Boloker and Mark VanderWiele explain how to put everything together in a clear and simple way using the power of the cloud, microservices, and real-time analytics.
Sharding is our go-to tool for handling failures and load balancing, and yet we software engineers rarely think about the quirks of what seems like a largely solved problem or consider the possibility that we can improve on its basic application. Wes Chow reviews some work—both old and recent—on controlling failures and adverse distributional effects.
The face of applications is changing, evolving into a continuous information experience where the interaction model is immersive, experiential, and multimodal. Stewart Nickolas discusses the set of architectural challenges this new interaction paradigm brings, from microservice-based conversations to service integration to deep learning systems that support conversational commerce.
If you have a roadmap that no one uses, it may be an anemic roadmap. An anemic roadmap is just a list of features that goes on as far as the eye can see. This is harmful to your organization. John Heintz explains how to build truly useful roadmaps that actually help us define goals and work jointly by weaving together marketing, product, architecture, and more.
Extracting value from data goes beyond robust ingestion pipelines and flexible storage. A solid data architecture addresses the needs of analysts and engineers by providing a simple, self-service ecosystem capable of handling any workload. Alex Silva discusses how the platform team at Pluralsight has been conquering these challenges by designing a platform using distributed, reactive services.
The many types of databases and data analysis tools available today offer developers tremendous options. Should you use a relational database? How about a key-value store? Maybe a document database? Or is a graph database the right fit for your project? Applying principles from domain-driven design, Bradley Holt helps you choose and apply the right data layer for your application’s model.
“Death Star” security describes a system that relies entirely on an outermost security layer and fails catastrophically when breached. David Strauss explores security methods strong enough to cross the public Internet, flexible enough to allow new services without altering existing systems, and robust enough to avoid single points of failure.
Architectural theory often takes a back seat to feature delivery; teams can deliver on a project as significant as migrating from a monolithic architecture to microservices while continuing to release new functionally. Christopher Grant offers some lessons learned as HomeDepot.com transitioned from monolith to microservices.
Artifactory’s use of hybrid storage has clear benefits, but what are the drawbacks? Fred Simon describes Artifactory’s journey to find harmony between ACID and CAP. Fred reviews the challenges in building a reliable and atomic system on top of eventually consistent storage and explains how Artifactory solved them for both standalone and clustered architectures.
Thomas Cozzolino highlights the growing importance of the developer experience, API-first thinking, common data models, and enterprise ecosystems.
Becoming cloud native means changing how we think about, develop, and deploy applications. This shift impacts the structure of organizations, as teams align to common business outcomes. Chip Childers explains why a successful cloud native approach requires a platform. Chip explores what it means to be truly cloud native, what it takes to get there, and how a platform can make it all work.
Threat modeling helps us think about what could go wrong and how to prevent it, but often when building software, we can't figure out how to connect threat models to real-world development and priorities—or we skip threat modeling altogether. Robert Hurlbut offers practical strategies for threat modeling for secure software design and explains how to apply risk management to deal with the threats.
Most firms have older web applications using legacy approaches; attempting to upgrade to a more modern standard is a unique challenge that means thinking about a wide array of radically different approaches. Josh Street explains how to modernize legacy web applications and walks attendees through some specific solutions for the challenges that can arise in these legacy systems.
Bulama Yusuf explains how he and his team introduced agile methodologies to build a mobile app with a cloud-based backend at an organization that previously used the waterfall method of software development (and had never built a mobile app before). Bulama outlines the challenges the team faced and the lessons they learned along the way.
Brian Sletten explores the intersection of design, architecture, and development, with the Web's resource-oriented abstractions serving as both information and architecture. Brian explains how this ties into the Web's organization, its software, the people using it, its requirements, and its security.
Results matter. Choosing a technology stack shouldn't be an either/or discussion. Thankfully, when it comes to the industry's two largest enterprise application platforms—Java EE and Spring—architects can cherry pick and integrate with ease. Markus Eisele and Joshua Long explain how architects and developers can benefit from the best of both technologies and embrace cloud-ready JVM architectures.
We've been trying to explain the pain of technical debt for generations, but we've never been able to measure it. What if we could measure the effects of learning curves, collaboration pain, and problems building up in the code? Janelle Klein outlines the Idea Flow Learning Framework, a strategy for measuring the friction in developer experience that introduces a whole new world of possibilities.
Every engineer dreams at some point of rewriting a legacy system. Rewrites introduce bugs, duplicate effort, and delays. Architectural evolution or incremental rewrites can be an alternative, but only if done properly. Michelle Brush explores good and bad patterns for evolving architectures, offering a framework for deciding what approach to take.
Nathaniel Schutta discusses a basic set of architectural diagrams. Drawing on a case study, Nathaniel walks attendees through constructing a set of diagrams that will effectively communicate their designs. In addition, Nathaniel covers stakeholders—explaining who might benefit from each type of diagram—and explores how to constructively review an architectural model.
Netflix is built on modern, efficient, and robust architectural concepts. Should you follow Netflix's lead and refactor your systems into microservices, split up big databases, and use polyglot approaches? Stefan Toth discusses an inverse architecture evaluation that embarc Software Consulting GmbH conducted to find the answers.
Kristoffer Dyrkorn outlines an infrastructure that reduces the steep cost of road construction and maintenance. The system provides high-quality and near real-time information by integrating an unusual combination of sensors, devices, protocols, and software. Kristoffer discusses architectural challenges met and choices and mistakes made while trying to keep the architecture receptive to change.
As every organization becomes a software organization, senior leaders with no technology background regularly have to make technology decisions. To help their teams succeed, architects must learn to coach those leaders in how to deliver and operate high-quality services. James Stewart covers a range of techniques that help develop understanding and capability among senior leadership.
Some workloads work better on a hypervisor hosted within an existing operating system, while others work better on a hypervisor run directly on bare metal with no operating system host. Russell Pavlicek explores a growing breed of solutions that specifically leverage the architecture of a bare-metal hypervisor to address new concepts.
Evolutionary architecture—also known as just-in-time architecture—is not as horrifying to developers and software architects as it once was. Rebecca Parsons explains how evolutionary architecture techniques and capabilities have evolved and explores how to apply evolutionary architecture in your work. If you’ve shunned evolutionary architecture in the past, it could be worth another look.
For years, software architects have worked with the idea that services are necessarily persistent: they must start and sit idle until they are needed. But lightweight, powerful microservices built on unikernels now allow services to appear precisely when needed and disappear when the need passes. Russell Pavlicek reviews unikernels and explains how they will change software architecture.
What do running and architecture have in common? Ted Malaska explains how long hours of training, blisters, and shin splints relate to life-changing lessons in software architecture.