Learn about new architecture patterns, event-driven microservices, fast data, and more.
The O’Reilly Programming Podcast: Building reactive applications.
Optimize for business value with clear feedback loops and quality standards.
Streaming architectures for data sets that never end.
The O’Reilly Programming Podcast: The Java module system and the “start of a new era.”
A Start-to-finish example with Angular and Typescript.
Explore the factors that make up a reactive microservice.
From developers to CTOs, everyone has a role to play in shaping their own transformation.
The O’Reilly Programming Podcast: A look at some of Python’s valuable, but often overlooked, features.
Discover what design patterns are and how they can be used to communicate solutions to common problems.
How to decouple your Java code using a mix of dependency injection, encapsulation, and services.
Learn about architectural safety measures, scaling data, caching schemes, service discovery, and more.
Formats, linking, and versioning are important in well-formed RESTful APIs.
The O’Reilly Programming Podcast: How to effectively make the transition from monoliths to microservices.
Learn how to properly design RESTful APIs communication with clients, accounting for request structure, authentication, and caching.
Learn how to manipulate smartphone behavior with common hyperlinks.
The O’Reilly Programming Podcast: The impact of ARKit on developers and consumers.
A simple framework for implementing message-based, user-initiated CRUD operations.
For stack scalability, elasticity at the business logic layer should be matched with elasticity at the caching layer.
The O’Reilly Programming Podcast: Wrangling data with Python’s libraries and packages.
Mark Richards explores two basic techniques for analyzing tradeoffs of architecture characteristics.
Neal Ford explains the ground rules for building software architectures.
Learn how NATS requests work and how to use the context package for cancellation.
How messages help you decouple, test, and re-use your software’s code.
The O’Reilly Programming Podcast: The skills needed to make the move from developer to architect.
Learn how the NATS client implements fast publishing and messages processing schemes viable for production use.
Structured bindings, new library types, and containers add efficiency and readability to your code.
Learn useful Go communication techniques from the internals of the NATS client.
The architectural design, automated quality assurance, and deployment skills needed for delivering continuous software.
The O’Reilly Programming Podcast: Applying architectural patterns and pattern languages to build systems for the cloud.
How software architects can balance technical proficiencies with an appropriate mastery of communication.
Identify the options available to develop an effective immersive experience.
The O’Reilly Programming Podcast: Embracing late changes, plurality, and decentralization.
Problem-solving is a key skill for students, new programmers, and those who work with them.
Get started orchestrating containerized applications at scale.
Michelle Brush highlights modern programming practices that deliver reproducibility in systems.
Dan North introduces some uncomfortable truths that help us unlock the true value from our technology.
Yiannis Kanellopoulos outlines deficiencies SIG found in its approach toward software developers and the key thing that helps developers realize their potential.
Learn about an approach that will subdue your monolithic application in stages.
Mark Richards explores the history and patterns of architectural modularity, and explains why modularity is so important.
Watch highlights covering modularity, platforms, and the evolving role of software architects. From the O'Reilly Software Architecture Conference in London 2017.
Nathaniel Schutta says architects are the Rosetta Stones of organizations, which means they must consciously think about the stories they're telling.
Neha Narkhede explains why streaming platforms have become the central nervous systems for modern digital businesses.
This chapter from Building Evolutionary Architectures describes architectures that support incremental change along with some of the engineering practices used to achieve incremental change.
The O’Reilly Programming Podcast: Inside the development of a new Go ecosystem.
The O’Reilly Programming Podcast: A look at a new systems programming language.
Know your options for managing checked exceptions in Java 8’s functional approach.
The O’Reilly Programming Podcast: A look at what’s new in Java 9 and Spring 5.
Learn how to set up an external job within Jenkins and manage its execution using the Jenkins command line interface.
Learn to install Ant software - and get it ready to integrate with Jenkins - by using the Jenkins automatic installation feature.
Learn how to automate Jenkins continuous integration projects with Apache Ant, a popular build tool for developing software.
The O’Reilly Programming Podcast: Building applications that work everywhere for everyone.
The O’Reilly Programming Podcast: The next technological evolution of cloud systems.
The O’Reilly Programming Podcast: Creating designs that are more flexible and resilient to change.
The O’Reilly Podcast: Helping developers improve performance, security, and service discoverability.
The O’Reilly Podcast: Modify your existing pipeline to embrace failure in isolation.
Save money, reduce repetitive operations, and shorten your time to market.
The O’Reilly Programming Podcast: Using Python decorators, generators, and functions.
The O’Reilly Programming Podcast: Principles for the successful adoption of microservices.
From building microliths to designing reactive microsystems.