x

Confirm Download

Simultaneous file downloading works best in FireFox, Chrome, and Safari browsers. Please keep this window open until all downloads are complete. Some customers prefer using file download managers for Chrome or Firefox to better manage large and multiple file downloads.

Cancel Download

O'Reilly Software Architecture Conference 2016 - New York, New York

      • The evolution of evolutionary architecture - Rebecca Parsons (ThoughtWorks)  (Free)

        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.
      • 00:18:18

      • Conversational commerce - Stewart Nickolas (IBM)  (Free)

        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.
      • 00:06:00

      • Going cloud native: It takes a platform - Chip Childers (Cloud Foundry Foundation)  (Free)

        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.
      • 00:11:25

      • Let's make the pain visible - Janelle Klein (New Iron)  (Free)

        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.
      • 00:18:49

      • MEAN Architecture 2.0 - Scott Davis (ThirstyHead.com) - Part 1

        Scott Davis is the founder of ThirstyHead, a training and consulting company that that specializes in leading-edge technology solutions like HTML5, the MEAN stack, mobile development, and smart TV development. Scott also cofounded the HTML5 Denver Users Group in 2011. Scott is the author and presenter of several O’Reilly videos, including Exploring the Architecture of the MEAN Stack and Responsive Mobile Architecture: Refactoring into Mobile HTML5.
      • 00:45:41

      • MEAN Architecture 2.0 - Scott Davis (ThirstyHead.com) - Part 2

        Scott Davis is the founder of ThirstyHead, a training and consulting company that that specializes in leading-edge technology solutions like HTML5, the MEAN stack, mobile development, and smart TV development. Scott also cofounded the HTML5 Denver Users Group in 2011. Scott is the author and presenter of several O’Reilly videos, including Exploring the Architecture of the MEAN Stack and Responsive Mobile Architecture: Refactoring into Mobile HTML5.
      • 00:49:22

      • Road traffic analysis and agile architectures - Kristoffer Dyrkorn (BEKK Consulting) - Part 1

        The construction and maintenance of roads is expensive. Metrics such as traffic speeds, volumes, patterns, and trends heavily influence how roads should be built and maintained. Improving the data quality of your metrics means you can plan and execute roadwork more efficiently. Kristoffer Dyrkorn outlines an infrastructure consisting of distributed sensors and signal processing devices, a data-ingestion application, and a NoSQL database optimized for analytics. The system registers information about vehicles passing measurement stations located along major roads and provides continuously updated reports and low-latency traffic event information.
      • 00:39:36

      • Road traffic analysis and agile architectures - Kristoffer Dyrkorn (BEKK Consulting) - Part 2

        The construction and maintenance of roads is expensive. Metrics such as traffic speeds, volumes, patterns, and trends heavily influence how roads should be built and maintained. Improving the data quality of your metrics means you can plan and execute roadwork more efficiently. Kristoffer Dyrkorn outlines an infrastructure consisting of distributed sensors and signal processing devices, a data-ingestion application, and a NoSQL database optimized for analytics. The system registers information about vehicles passing measurement stations located along major roads and provides continuously updated reports and low-latency traffic event information.
      • 00:48:44

      • It probably works: Deploying probabilistic algorithms on a large scale - Tyler McMullen (Fastly)

        Probabilistic algorithms exist to solve problems that are either impossible or unrealistic (too expensive, too time consuming, etc.) to solve precisely. In an ideal world, you would never actually need to use probabilistic algorithms. For programmers who are not familiar with them, the concept can be positively nerve-racking: “How do I know it will actually work? What if it is inexplicably wrong? How can I debug it? Maybe we should just punt on this problem or buy a whole lot more servers. . .”
      • 00:45:50

      • Beyond multitenancy: Introducing a new container-based application factory - Thierry Delprat (Nuxeo)

        Thierry offers a new application-factory infrastructure, using customized Docker containers deployed on demand for each tenant, built to avoid the limitations of multitenancy while still being able to be managed as a single application. Thierry describes the design choices his team made and explains how they built this infrastructure. He also explores how Nuxeo uses it in production to deliver the nuxeo.io services and how this container-based application factory model optimizes the hosting costs by providing high-density container hosting on top of AWS EC2 and passivation/on-demand activation of dataless containers.
      • 00:47:13

      • How to have your causality and wall clocks too - Jon Moore (Comcast Cable)

        Jon Moore describes evolving research into distributed monotonic clocks (DMCs), which can reflect causality like Lamport clocks while retaining a component that stays close to the wall-clock time that is meaningful to human operators, allowing application timestamps to come out in the right order even without perfect clock synchronization.
      • 00:54:17

      • Leading simplicity - Sam Lambert (GitHub)

        It is important for leaders to guide their teams toward pragmatic technical choices and avoid complexity. Much of building software is about picking your challenges. By making sensible technical choices, you can move fast without compromising stability. Sam Lambert describes how GitHub is building a world-leading, cutting-edge platform on top of stable, proven technologies.
      • 00:39:25

      • Apache Kafka and the stream data platform - Jay Kreps (Confluent)

        Jay demonstrates how real-time streams can become the source of ETL into Hadoop or a relational data warehouse and how real-time data can supplement the role of batch-oriented analytics in Hadoop or a traditional data warehouse. He also describes the role of emerging stream processing layers such as Storm and Spark that work with Kafka to allow applications to make use of these streams for sophisticated real-time data processing applications.
      • 00:49:25

      • Enhancing society with APIs at the New York Times - Scott Feinberg (The New York Times Company)

        Scott Feinberg explains how the New York Times is actively iterating and improving its workflow, with the goal of creating the lowest-friction API usage experience for teams. Scott explores how this approach to developing, managing, documenting, and testing internal APIs has evolved over time and how teams use the same systems and techniques to fulfill the core mission through an external API program.
      • 00:41:11

      • Building better distributed data pipelines - Patrick McFadin (DataStax)

        Patrick McFadin explains the basics of how to build more efficient data pipelines, using Apache Kafka to organize, Apache Cassandra to store, and Apache Spark to analyze. Patrick offers an overview of how Cassandra works and why it can be a perfect fit for data-driven projects. Patrick then demonstrates that with the addition of Spark and Kafka, you can maintain a highly distributed, fault-tolerant, and scaling solution. You’ll leave with a comprehensive view of the many options to make considered choices in your data pipeline projects.
      • 00:53:51

      • Modeling for Architects - Nathaniel Schutta (Ntschutta.com) - Part 1

        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.
      • 00:41:53

      • Modeling for architects - Nathaniel Schutta (Ntschutta.com) - Part 2

        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.
      • 00:30:26

      • Modeling for architects - Nathaniel Schutta (Ntschutta.com) - Part 3

        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.
      • 00:38:10

      • Architectural Katas - Ted Neward (Neward & Associates, LLC)

        The Architectural Katas are proven exercises designed to maximize the architectural effort, minimize the unnecessary overhead, and complete all the critical elements that any architectural exercise should include: changing requirements, a customer, project constraints, a deadline, peers, and a review process. Ted Neward leads a hands-on workshop where, in small groups, you’ll answer an RFP, cook up an architecture, and present it for review. It’s the quickest way to experiment without risking your job. No prior experience as an architect is required. In fact, having no experience might even be more beneficial - you’ll have no preexisting ideas about how it “should” be done.
      • 00:18:10

      • Zen of architecture - Juval Löwy (IDesign Inc.) - Part 1

        In this dense tutorial, Juval Löwy explains his approach to large system analysis and design: using volatility to decompose a system into its comprising services. Juval contrasts this approach with the most common mistake made in architecture—using functionality to identify services—and outlines universal design principles, explained with examples from software and nonsoftware systems alike.
      • 00:46:41

      • Zen of architecture - Juval Löwy (IDesign Inc.) - Part 2

        In this dense tutorial, Juval Löwy explains his approach to large system analysis and design: using volatility to decompose a system into its comprising services. Juval contrasts this approach with the most common mistake made in architecture—using functionality to identify services—and outlines universal design principles, explained with examples from software and nonsoftware systems alike.
      • 00:52:46

      • Zen of architecture - Juval Löwy (IDesign Inc.) - Part 3

        In this dense tutorial, Juval Löwy explains his approach to large system analysis and design: using volatility to decompose a system into its comprising services. Juval contrasts this approach with the most common mistake made in architecture—using functionality to identify services—and outlines universal design principles, explained with examples from software and nonsoftware systems alike.
      • 00:47:36

      • Zen of architecture - Juval Löwy (IDesign Inc.) - Part 4

        In this dense tutorial, Juval Löwy explains his approach to large system analysis and design: using volatility to decompose a system into its comprising services. Juval contrasts this approach with the most common mistake made in architecture—using functionality to identify services—and outlines universal design principles, explained with examples from software and nonsoftware systems alike.
      • 00:49:22

      • Let's not rewrite it all - Michelle Brush (Cerner Corporation)

        Michelle Brush explores approaches to migrating code to new architectures based on business needs. Michelle explains how to identify the right approach for the codebase by understanding the goals of the project and the complexity of the domain. Michelle also covers architectural evolution failures and successes, pointing out the key aspects that determined the outcome.
      • 00:40:48

      • Domain-driven data - Bradley Holt (IBM Cloud Data Services)

        Applying principles from domain-driven design, such as strategic design and bounded contexts, Bradley Holt helps developers choose and apply the right data layer for their application’s model or models as he explores the traditional relational database, graph databases, document databases, key/value stores, polyglot persistence, CQRS, event sourcing, and data layers for microservices.
      • 00:43:57

      • How to modernize legacy web applications - Josh Street (AmWINS)

        Josh Street explores these challenges, which range from personnel-related issues (uptiering talent) to design issues (managing architectural mismatches and legacy technical debt), offering the information that will give your project the best chance for success. Josh explains how to modernize legacy web applications—from choosing the platform and technologies used to organizing the teams to executing and managing the project—and walks attendees through some specific solutions for the challenges that can arise in these legacy systems.
      • 01:08:38

      • The architect's clue bucket - Ruth Malan (Bredemeyer Consulting) - Part 1

        Sometimes we just need to get a clue, and this talk has a bucket full. Ruth Malan explores the playful idea of a clue bucket (so that we can reach in and get a clue when we need one). Ruth considers sources of design inspiration—along with a collection of design guides, principles, tips, and heuristics—which she contextualizes by outlining the kinds of challenges the architect addresses.
      • 00:28:11

      • The architect's clue bucket - Ruth Malan (Bredemeyer Consulting) - Part 2

        Sometimes we just need to get a clue, and this talk has a bucket full. Ruth Malan explores the playful idea of a clue bucket (so that we can reach in and get a clue when we need one). Ruth considers sources of design inspiration—along with a collection of design guides, principles, tips, and heuristics—which she contextualizes by outlining the kinds of challenges the architect addresses.
      • 00:54:11

      • A year with event sourcing and CQRS - Stephen Pember (ThirdChannel) - Part 1

        As businesses grow, so does the complexity of their software. New features, new models, and new background processes all continue to be added. . .and developers struggle to make sense of it all. Yet the end user demands a swift and functional experience when interacting with your application. It is paramount to be open to alternative patterns that help tame complex, high-demand services. Two such patterns are command-query responsibility segregation (CQRS) and event sourcing (ES).
      • 00:46:13

      • A year with event sourcing and CQRS - Stephen Pember (ThirdChannel) - Part 2

        As businesses grow, so does the complexity of their software. New features, new models, and new background processes all continue to be added. . .and developers struggle to make sense of it all. Yet the end user demands a swift and functional experience when interacting with your application. It is paramount to be open to alternative patterns that help tame complex, high-demand services. Two such patterns are command-query responsibility segregation (CQRS) and event sourcing (ES).
      • 00:41:14

      • Architecture without an end state - Michael Nygard (Cognitect, Inc.)

        You’ve seen them. In fact, you’ve probably even made one. Architecture vision diagrams: the block diagrams, the message bus topologies. . .But how many of these diagrams ever actually get built? We never really finish constructing one of these grand visions before something interferes. Maybe it’s a merger or acquisition. Maybe your company has a regime change. (After all, the average tenure of a CIO is down to 18 months.) Regardless, the “end state” vision never gets built.
      • 00:46:09

      • Microservices tutorial - Cassandra Shum and Maria Gomez (ThoughtWorks) - Part 1

        In a hands-on tutorial, Cassandra Shum and María Gómez explore microservices and demonstrate how to deploy service-oriented software using the popular DevOps tool Docker. Participants will learn a continuous delivery approach focused on building, testing, and deploying independent microservices to production continuously and autonomously.
      • 00:29:46

      • Microservices tutorial - Cassandra Shum and Maria Gomez (ThoughtWorks) - Part 2

        In a hands-on workshop, Cassandra Shum and María Gómez explore microservices and demonstrate how to deploy service-oriented software using the popular DevOps tool Docker. Participants will learn a continuous delivery approach focused on building, testing, and deploying independent microservices to production continuously and autonomously.
      • 00:38:35

      • Microservices tutorial - Cassandra Shum and Maria Gomez (ThoughtWorks) - Part 3

        In a hands-on workshop, Cassandra Shum and María Gómez explore microservices and demonstrate how to deploy service-oriented software using the popular DevOps tool Docker. Participants will learn a continuous delivery approach focused on building, testing, and deploying independent microservices to production continuously and autonomously.
      • 00:39:29

      • Microservices tutorial - Cassandra Shum and Maria Gomez (ThoughtWorks) - Part 4

        In a hands-on workshop, Cassandra Shum and María Gómez explore microservices and demonstrate how to deploy service-oriented software using the popular DevOps tool Docker. Participants will learn a continuous delivery approach focused on building, testing, and deploying independent microservices to production continuously and autonomously.
      • 00:21:29

      • 12 patterns for hypermedia service architecture - Mike Amundsen (API Academy, CA Technologies)

        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. Whether you are responsible for building web frontends or APIs to serve those apps, Mike helps you identify key principles to increase the adaptability and evolvability of your web implementations.
      • 00:48:37

      • Containers and microservices: New ways to deploy and manage applications at scale - Jake Moshenko (CoreOS)

        Many organizations are beginning to adopt microservices in an attempt to streamline product delivery and increase developer agility. But this new style of application architecture requires a shift in thinking about how we approach building out the underlying infrastructure. Thanks to continuous delivery, applications are now being deployed faster than ever. This increase in application agility has accelerated the adoption of new technologies such as application containers and cluster management tools, which aim to provide the automated application deployments and scheduling, autoscaling, and self-healing capabilities required by modern infrastructure deployments.
      • 00:49:26

      • Cloud in your cloud: How we build DigitalOcean - Matthew Campbell (Digital Ocean)

        Matthew explains why DigitalOcean uses a combination of Go, Ruby, and Perl to build microservices and discusses the trade-offs of different RPC protocols such as gRPC and HTTP/JSON. Matthew then dives into how DigitalOcean manages service discovery with Consul on thousands of nodes and monitors the health and performance of the cloud, as well as how it uses structured logging with Kibana.
      • 00:40:50

      • Butterfly in reverse: From SOA to monolith - Mark Bates (Meta42 Labs, LLC)

        Mark discusses how he started building his application “correctly” and ended up with the classic monolith architecture you hear people warning against. Mark explains why Go, SOA, and Angular were the wrong choices for this app and why the monolith was the right answer. Along the way, you’ll learn a thing or two about making the correct architectural choices for your organization. At the very least, you’ll hear some funny stories about Mark’s pain, expressed through a few choice animated GIFs.
      • 00:43:49

      • Microservices: What's missing. . . - Adrian Cockcroft (Battery Ventures)

        Many people have now figured out how to get started with microservices, and there are frameworks available for most common languages and platforms. Adrian Cockcroft explores some key aspects of successful large-scale microservice deployments that tend to be skipped and explains how this can lead to common problems in the transition. Adrian digs into important issues including but not limited to versioning, routing, protocols, failure injection testing, denormalized data models, distributed transactions, monitoring, and simplicity through symmetry.
      • 00:55:55

      • Maneuverable architecture - Michael Nygard (Cognitect, Inc.)

        Michael Nygard explores systems that can be recombined in novel ways to tackle changing business challenges. As architects, we can change the way we integrate systems to produce maneuverability, via different techniques and patterns. Some of these techniques may appear to contradict past notions of sound architecture. Our industry evolves rapidly, however, and last year’s sound practice might just be a drag this year.
      • 00:44:34

      • Reverse evaluating Netflix's architecture - Stefan Toth (embarc Software Consulting GmbH)

        Stefan Toth discusses an architecture evaluation that embarc Software Consulting GmbH conducted based on the Architecture Trade-off Analysis Method (ATAM)—but applied in reverse: starting with the known architectural approaches, embarc extracted the most useful requirements and attributes, as well as important trade-offs and constraints. Embarc’s findings illustrate the pros and cons of current technological trends so you can decide how they would fit your own context.
      • 00:53:03

      • An introduction to reactive applications, Reactive Streams, and options for the JVM - Stephen Pember (ThirdChannel) - Part 1

        Stephen Pember explores the various definitions of reactive and reactive programming with the goal of providing techniques for building efficient, scalable applications. Steve dives into the key concepts of Reactive Streams and examines some sample implementations—including how ThirdChannel is currently using reactive libraries in production code. Steve looks at some of the open source options available in the JVM—including Reactor, RxJava, and Ratpack—giving attendees an idea of where to begin with the reactive ecosystem. If reactive is new to you, this should be an excellent introduction.
      • 00:52:00

      • An introduction to reactive applications, Reactive Streams, and options for the JVM - Stephen Pember (ThirdChannel) - Part 2

        Stephen Pember explores the various definitions of reactive and reactive programming with the goal of providing techniques for building efficient, scalable applications. Steve dives into the key concepts of Reactive Streams and examines some sample implementations—including how ThirdChannel is currently using reactive libraries in production code. Steve looks at some of the open source options available in the JVM—including Reactor, RxJava, and Ratpack—giving attendees an idea of where to begin with the reactive ecosystem. If reactive is new to you, this should be an excellent introduction.
      • 00:31:18

      • Designing a reactive data platform: Challenges, patterns, and antipatterns - Alex Silva (Pluralsight)

        Alex covers the key architectural decisions Pluralsight made as it moved from a blank slate to a fully reactive self-service platform that is able to fulfill several business use cases, ranging from data ingestion to analysis, at both real-time and batch scales. Pluralsight’s current implementation consists of discrete microservices running on top of the JVM, using a mixture of Scala, Akka, and Java. Alex shares Pluralsight’s event-driven, reactive design that leverages REST, Hypermedia, and several open source frameworks and platforms, including Spring, Hadoop, YARN, Kafka, Storm, and Spark.
      • 00:49:31

      • Building a status dashboard with a server-free architecture - Prasanna Swaminathan (MediaMath)

        Web-hosting options have changed dramatically in the last decade and a half as web applications have predominated, shifting from shared hosting to VPS to PaaS. Unfortunately, these options all require servers, and servers are difficult. It is extremely challenging to establish parity between dev and production environments and reproduce it, both in provisioning and deployment. In order to scale successfully, web apps have to tackle multidimensional problems, sometimes relying on tools like Heroku to ease the burden.
      • 00:34:18

      • A biological and human approach to architecture: How New Relic builds to scale - Brent Miller (New Relic, Inc.)

        When building resilient, fault-tolerant, scalable systems, we focus quite a bit on the particular technologies involved. Can they scale horizontally? Is Samza better than Storm? Is this library thread-safe? It turns out that even though those questions matter to the stability of the system, they aren’t as important as the people building the system. Humans choose the stack, write the code, and write the bugs, too. They create the weird edge cases that cause the system to fall over at the worst time.
      • 00:51:09

      • Modern backends for mobile apps - Sasha Goldshtein (Sela Group)

        Backend concerns for mobile apps include data storage, efficient queries, push notifications, and user authentication. Sasha Goldshtein discusses cloud backend providers that take away the burden of managing servers and infrastructure for your mobile apps. Sasha explores the system architecture and concrete design for mobile apps that rely on Azure Mobile Services, Facebook Parse, and cloud storage providers as a ready-made backend. You’ll learn how to store large amounts of data in the cloud, how to deliver millions of targeted push notifications, and how to use OAuth 2.0 for user authentication and authorization.
      • 00:39:57

      • From ACID to CAP and back again: Making S3 reliable - Fred Simon (JFrog Inc)

        Artifactory’s use of hybrid storage has clear benefits: while artifacts are stored on the file system in a layout-independent manner, all the metadata is kept in a fast and reliable indexed database. But how can you leverage a robust, clustered, and highly available storage solution like AWS-S3 and make it work with the metadata and other features of Artifactory? How do you couple eventually consistent storage like S3 with a strong storage consistency model required by your CI? 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.
      • 00:57:18

      • Shipping a Ruby on Rails stack to thousands of companies every month - Marin Jankovski (GitLab)

        GitLab—built on Ruby on Rails—has a complex stack that has to be able to scale on-premises yet also run on a single VM. Every month, GitLab releases a new version of the software as a single Omnibus package. GitLab’s Omnibus packages allow for zero-downtime deployments on any infrastructure, can be run in highly available configurations, and contain everything from database to web server to dependencies.
      • 00:30:05

      • The architect as coach - James Stewart (Government Digital Service)

        Experienced architects can help manage this situation by acting as coaches and translators, working with leaders to help them understand the responsibilities that come with owning a digital service, work out how to build trust with teams and verify results, and determine what they need to prepare for. Drawing on his experience with the UK government’s digital transformation, James Stewart covers a range of techniques that help develop understanding and capability among senior leadership and explores the role architects can play.
      • 00:31:25

      • AppSec and microservices - Sam Newman (ThoughtWorks)

        Microservices allow us many options to pick different technologies, mix synchronous and asynchronous integration techniques, or embrace different deployment patterns. But they also offer a variety of options for how we think about securing our systems. Done right, microservices can increase the security of your vital data and processes. Done wrong, you can increase the surface area of attack. Sam Newman discusses the fundamentals of application security in the context of microservices, exploring the many different ways in which you can secure your fine-grained, distributed architectures.
      • 00:42:50

      • How to make threat modeling work for you - Robert Hurlbut (Robert Hurlbut Consulting Services)

        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.
      • 00:55:42

      • Connect and control IoT devices in minutes - David Boloker (IBM Corporation), Mark Vanderwiele (IBM Corporation)

        The world of the IoT is exploding with respect to sensors—sensors are everywhere from buildings (measuring temperature, humidity, movement, etc.) to cities (measuring sound, air, security, etc.)—and speech and analytics are providing a powerful new user experience. David Boloker and Mark VanderWiele explain how to put everything together—architecturally as well as physically—in a clear and simple way using the power of the cloud, microservices, and real-time analytics.
      • 00:53:45

      • Conversational commerce - Stewart Nickolas (IBM)

        Architectures are under relentless pressure to evolve—and do so quickly. At the confluence of cloud, social, and cognitive is a new set of capabilities and opportunities not possible before. We are seeing the emergence of a conversational stye of user interface beyond simple command and control of applications. Imagine not having to learn how to use an application, instead simply asking for and receiving the information you want. We converse with each other and machines to ask questions, collaborate, take action, teach our digital world new things, and purchase goods and services.
      • 00:39:36

      • Best practices for implementing serverless architecture - Chad Arimura (Iron.io)

        Modern applications are moving away from the traditional request/response loop to more event-driven patterns. As applications move toward microservices and modern architectural design patterns, the concept of “serverless” computing often comes up. Now is the dawn of the serverless age. We’re entering a world where developers won’t have to think about provisioning resources to run their code. While serverless computing sounds like nirvana, there’s an upfront investment in changing development and operational patterns to allow for such a level of automated orchestration.
      • 00:42:04

O'Reilly Software Architecture Conference 2016 - New York, New York

  • Publisher: O'Reilly Media
  • Released: April 2016
  • Run time: 52 hours 23 minutes

SACON 2016 New York offered 57 presentations on the challenges software architects face as they engineer the future of software. The conference revolved around nine specific themes (reactive and it’s variants, integration architecture, scale, security, dev ops, etc.) with an emphasis on architecture fundamentals (when to migrate legacy code, choosing the correct data layer, etc.); designing distributed systems (creating real-time data pipelines using Apache Kafka, Cassandra and Spark; building better application-factory infrastructures using container-based multitenancy, etc.); and on the pros and cons of microservices (ten sessions on this topic alone).

Get this video compilation and you’ll have at your-own-pace access to 64 software architects with world-wide cred, including such notables as Thierry Delprat, CTO, Nuxeo; Rebecca Parsons, CTO, ThoughtWorks; David Boloker, CTO, Emerging Internet Technology, IBM; Ted Malaska, Solutions Architect, Cloudera; Chad Arimura, CEO, Iron.io; Sam Lambert, Systems Director, GitHub; and many more. Purchasers can download the videos or view them through our HD player.

  • See all seven keynotes, all seven tutorials and each of the 43 sessions
  • Understand the pros and cons of refactoring your systems into microservices
  • Learn to embrace cloud-ready JVM architecture by integrating the best from Java EE and Spring
  • Explore how to design resilient applications in the face of unexpected failure and load situations
  • Hear about new research surrounding distributed monotonic clocks and NTP
  • Learn 12 patterns and practices for building microservice APIs that can safely evolve over time
  • Discover why "SOA good, monolith bad" isn't always true
  • Learn to conduct a skillful past-mortem that reveals the causes of architectural failure and success
  • Hear how the New York Times, GitHub, and HomeDepot faced the microservices challenge