Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1DXFg0h.
Ben Christensen summarizes why the Rx programming model was chosen and demonstrates how it is applied to a variety of use cases. Filmed at qconsf.com.
Ben Christensen is a software engineer on the Netflix Edge Services Platform team responsible for fault tolerance, performance, architecture and scale while enabling millions of customers to access the Netflix experience across more than 1,000 different device types.
Everything you wanted to know about writing async, concurrent http apps in java Baruch Sadogursky
As presented at CodeMotion Tel Aviv:
Facing tens of millions of clients continuously downloading binaries from its repositories, JFrog decided to offer an OSS client that natively supports these downloads. This session shares the main challenges of developing a highly concurrent, resumable, async download library on top of an Apache HTTP client. It also covers other libraries JFrog tested and why it decided to reinvent the wheel. Consider yourself forewarned: lots of HTTP internals, NIO, and concurrency ahead!
Presentation: Everything you wanted to know about writing async, high-concurr...Baruch Sadogursky
Facing tens of millions of clients continuously downloading binaries from our repositories, we decided to offer an OSS client that natively supports these downloads. In this talk we will share the main challenges in developing a highly-concurrent, resumable, async download library on top of Apache HTTP client. We will cover other libraries we tested and why we decided to reinvent the wheel. We will see important pitfalls we came across when working with HTTP and how using the right combination of techniques can improve performance by a magnitude. We will also see why your initial assumptions may completely change when faced with other players on the network. Consider yourself forewarned: lots of HTTP internals, NIO and concurrency ahead!
As presented at JFokus 2015 (http://www.jfokus.se/jfokus/talks.jsp#Everythingyouwantedt)
Reactive Streams: Handling Data-Flow the Reactive WayRoland Kuhn
Building on the success of Reactive Extensions—first in Rx.NET and now in RxJava—we are taking Observers and Observables to the next level: by adding the capability of handling back-pressure between asynchronous execution stages we enable the distribution of stream processing across a cluster of potentially thousands of nodes. The project defines the common interfaces for interoperable stream implementations on the JVM and is the result of a collaboration between Twitter, Netflix, Pivotal, RedHat and Typesafe. In this presentation I introduce the guiding principles behind its design and show examples using the actor-based implementation in Akka.
Streams, Streams Everywhere! An Introduction to RxAndrzej Sitek
Nowadays users expect real time data - tweets, messages, order confirmations etc. - the user's attitude moved to the “push" model and it is high time for us devs to make that step as well.
Reactive Extensions (Rx) is the new hot stuff amongst developers these days. It is a library for composing asynchronous and event-based programs by using observable sequences. Sounds nice?
The only problem is that it can be a bit difficult to approach initially, especially when you come from an imperative world, but once mastered it helps dealing with some common problems in a nicer and cleaner way making your code more readable and easier to maintain.
Multiple implementations of Reactive Extensions helps reusing once learnt concepts between different programming languages. The aim of this talk is to provide a quick introduction to Rx theory and potential usecases. The examples are based on RxJava - the Java VM implementation of Reactive Extensions.
After explaining what problem Reactive Programming solves I will give an introduction to one implementation: RxJava. I show how to compose Observable without concurrency first and then with Scheduler. I finish the talk by showing examples of flow control and draw backs.
Inspired from https://www.infoq.com/presentations/rxjava-reactor and https://www.infoq.com/presentations/rx-service-architecture
Code: https://github.com/toff63/Sandbox/tree/master/java/rsjug-rx/rsjug-rx/src/main/java/rs/jug/rx
Everything you wanted to know about writing async, concurrent http apps in java Baruch Sadogursky
As presented at CodeMotion Tel Aviv:
Facing tens of millions of clients continuously downloading binaries from its repositories, JFrog decided to offer an OSS client that natively supports these downloads. This session shares the main challenges of developing a highly concurrent, resumable, async download library on top of an Apache HTTP client. It also covers other libraries JFrog tested and why it decided to reinvent the wheel. Consider yourself forewarned: lots of HTTP internals, NIO, and concurrency ahead!
Presentation: Everything you wanted to know about writing async, high-concurr...Baruch Sadogursky
Facing tens of millions of clients continuously downloading binaries from our repositories, we decided to offer an OSS client that natively supports these downloads. In this talk we will share the main challenges in developing a highly-concurrent, resumable, async download library on top of Apache HTTP client. We will cover other libraries we tested and why we decided to reinvent the wheel. We will see important pitfalls we came across when working with HTTP and how using the right combination of techniques can improve performance by a magnitude. We will also see why your initial assumptions may completely change when faced with other players on the network. Consider yourself forewarned: lots of HTTP internals, NIO and concurrency ahead!
As presented at JFokus 2015 (http://www.jfokus.se/jfokus/talks.jsp#Everythingyouwantedt)
Reactive Streams: Handling Data-Flow the Reactive WayRoland Kuhn
Building on the success of Reactive Extensions—first in Rx.NET and now in RxJava—we are taking Observers and Observables to the next level: by adding the capability of handling back-pressure between asynchronous execution stages we enable the distribution of stream processing across a cluster of potentially thousands of nodes. The project defines the common interfaces for interoperable stream implementations on the JVM and is the result of a collaboration between Twitter, Netflix, Pivotal, RedHat and Typesafe. In this presentation I introduce the guiding principles behind its design and show examples using the actor-based implementation in Akka.
Streams, Streams Everywhere! An Introduction to RxAndrzej Sitek
Nowadays users expect real time data - tweets, messages, order confirmations etc. - the user's attitude moved to the “push" model and it is high time for us devs to make that step as well.
Reactive Extensions (Rx) is the new hot stuff amongst developers these days. It is a library for composing asynchronous and event-based programs by using observable sequences. Sounds nice?
The only problem is that it can be a bit difficult to approach initially, especially when you come from an imperative world, but once mastered it helps dealing with some common problems in a nicer and cleaner way making your code more readable and easier to maintain.
Multiple implementations of Reactive Extensions helps reusing once learnt concepts between different programming languages. The aim of this talk is to provide a quick introduction to Rx theory and potential usecases. The examples are based on RxJava - the Java VM implementation of Reactive Extensions.
After explaining what problem Reactive Programming solves I will give an introduction to one implementation: RxJava. I show how to compose Observable without concurrency first and then with Scheduler. I finish the talk by showing examples of flow control and draw backs.
Inspired from https://www.infoq.com/presentations/rxjava-reactor and https://www.infoq.com/presentations/rx-service-architecture
Code: https://github.com/toff63/Sandbox/tree/master/java/rsjug-rx/rsjug-rx/src/main/java/rs/jug/rx
Building Scalable Stateless Applications with RxJavaRick Warren
RxJava is a lightweight open-source library, originally from Netflix, that makes it easy to compose asynchronous data sources and operations. This presentation is a high-level intro to this library and how it can fit into your application.
End to End Akka Streams / Reactive Streams - from Business to SocketKonrad Malawski
The Reactive Streams specification, along with its TCK and various implementations such as Akka Streams, is coming closer and closer with the inclusion of the RS types in JDK 9. Using an example Twitter-like streaming service implementation, this session shows why this is a game changer in terms of how you can design reactive streaming applications by connecting pipelines of back-pressured asynchronous processing stages. The presentation looks at the example from two perspectives: a raw implementation and an implementation addressing a high-level business need.
Bulding a reactive game engine with Spring 5 & CouchbaseAlex Derkach
A social game, by it’s nature can spread very quickly to a large user audience. Since a game is typically interactive, the speed of retrieving information needed for the user’s interactions with the system is critical. Applications which exclusively rely on synchronous data access, very often hit a scalability wall, when things get slow and their thread pools are exhausted. New paradigms like reactive programming alleviate this and provide extensive tool sets to deal with the ever growing demands of web applications.
This talk:
– Describes why Couchbase is the most appropriate solution for many video game and gaming use cases.
– Shows how to build scalable and reactive applications by making use of the Couchbase Java SDK 2.x, RxJava library and Spring Framework 5.
Presentation given at SoCal .NET Architecture group in March 2015. We introduced the async/await keywords and discussed architectural considerations: like why async may be superior to Parallel.ForEach and other parallel options, especially for server-side scaling
Reactive Streams are a cross-company initiative first ignited by Lightbend in 2013, soon to be joined by RxJava and other implementations focused on solving a very similar problem: asynchronous non-blocking stream processing, with guaranteed over-flow protection. Fast forward to 2016 and now these interfaces are part of JSR-266 and proposed for JDK9.
In this talk we'll first disambiguate what the word Stream means in this context (as it's been overloaded recently by various different meanings), then look at how its protocol works and how one might use it in the real world showing examples using existing implementations.
We'll also have a peek into the future, to see what the next steps for such collaborative protocols and the JDK ecosystem are in general.
This is the Async / Await feature added to .NET in .NET 4.5, specifically...Everything I Wish I Knew When I Started Using It! By avoiding the client side discussions around the UI and parallel processing, we can focus on the environment in which most of us live and have both an introduction and deeper dive into how it all works. This is about how we can all use the feature RIGHT NOW to write better performing code.
The new Actor representation in Akka Typed allows formulations that lend themselves to monadic interpretation or introspection. This leads us to explore possibilities for expressing and verifying dynamic properties like the adherence to a communication protocol between multiple agents as well as the safety properties of that protocol on a global level. Academic research in this area is far from complete, but there are interesting initial results that we explore in this session: precisely how much purity and reasoning can we bring to the distributed world?
A practical guide to using RxJava on Android. Tips for improving your app architecture with reactive programming. What are the advantages and disadvantages of using RxJava over standard architecture? And how to connect with other popular Android libraries?
Presented at GDG DevFest The Netherlands 2016.
PyCon AU 2012 - Debugging Live Python Web ApplicationsGraham Dumpleton
Monitoring tools record the result of what happened to your web application when a problem arises, but for some classes of problems, monitoring systems are only a starting point. Sometimes it is necessary to take more intrusive steps to plan for the unexpected by embedding mechanisms that will allow you to interact with a live deployed web application and extract even more detailed information.
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1Ihu917.
Jafar Husain shows the Reactive Extensions (Rx) library which allows to treat events as collections, how Netflix uses Rx on the client and the server, allowing to build end-to-end reactive systems. Filmed at qconsf.com.
Jafar Husain developed software for companies like GE, Microsoft, and Netflix. He specializes in building web servers and clients using functional reactive programming, and was the first user of the Reactive Extensions Framework. He's also responsible for "Falkor", a RESTful data access framework that powers most Netflix clients.
.NET Fest 2018. Антон Молдован. One year of using F# in production at SBTechNETFest
В 2017 году мы начали активно использовать F# для построения high-load push-based queryable API, а также обработки больших потоков данных (stateful stream processing). На тот момент времени никто в наших командах не имел предыдущего опыта по внедрению и применению F# но мы решили попробовать. На этом докладе я расскажу о нашем опыте внедрения F#, его проблемах и недостатках, о том как мы его научились готовить, где имеет смысл его применять и как подружить C#/OOP с F#/FP в одном проекте.
Данный доклад нацелен на аудиторию не имеющую предыдущего опыта с FP/F#.
Agenda:
- Why did we choose F# over C#?
- A high-level overview of the architecture of our push-based queryable API.
- Adopting F# for C#/OOP developers (inconveniences, C# interoperability, code style, DDD, TDD)
Building Scalable Stateless Applications with RxJavaRick Warren
RxJava is a lightweight open-source library, originally from Netflix, that makes it easy to compose asynchronous data sources and operations. This presentation is a high-level intro to this library and how it can fit into your application.
End to End Akka Streams / Reactive Streams - from Business to SocketKonrad Malawski
The Reactive Streams specification, along with its TCK and various implementations such as Akka Streams, is coming closer and closer with the inclusion of the RS types in JDK 9. Using an example Twitter-like streaming service implementation, this session shows why this is a game changer in terms of how you can design reactive streaming applications by connecting pipelines of back-pressured asynchronous processing stages. The presentation looks at the example from two perspectives: a raw implementation and an implementation addressing a high-level business need.
Bulding a reactive game engine with Spring 5 & CouchbaseAlex Derkach
A social game, by it’s nature can spread very quickly to a large user audience. Since a game is typically interactive, the speed of retrieving information needed for the user’s interactions with the system is critical. Applications which exclusively rely on synchronous data access, very often hit a scalability wall, when things get slow and their thread pools are exhausted. New paradigms like reactive programming alleviate this and provide extensive tool sets to deal with the ever growing demands of web applications.
This talk:
– Describes why Couchbase is the most appropriate solution for many video game and gaming use cases.
– Shows how to build scalable and reactive applications by making use of the Couchbase Java SDK 2.x, RxJava library and Spring Framework 5.
Presentation given at SoCal .NET Architecture group in March 2015. We introduced the async/await keywords and discussed architectural considerations: like why async may be superior to Parallel.ForEach and other parallel options, especially for server-side scaling
Reactive Streams are a cross-company initiative first ignited by Lightbend in 2013, soon to be joined by RxJava and other implementations focused on solving a very similar problem: asynchronous non-blocking stream processing, with guaranteed over-flow protection. Fast forward to 2016 and now these interfaces are part of JSR-266 and proposed for JDK9.
In this talk we'll first disambiguate what the word Stream means in this context (as it's been overloaded recently by various different meanings), then look at how its protocol works and how one might use it in the real world showing examples using existing implementations.
We'll also have a peek into the future, to see what the next steps for such collaborative protocols and the JDK ecosystem are in general.
This is the Async / Await feature added to .NET in .NET 4.5, specifically...Everything I Wish I Knew When I Started Using It! By avoiding the client side discussions around the UI and parallel processing, we can focus on the environment in which most of us live and have both an introduction and deeper dive into how it all works. This is about how we can all use the feature RIGHT NOW to write better performing code.
The new Actor representation in Akka Typed allows formulations that lend themselves to monadic interpretation or introspection. This leads us to explore possibilities for expressing and verifying dynamic properties like the adherence to a communication protocol between multiple agents as well as the safety properties of that protocol on a global level. Academic research in this area is far from complete, but there are interesting initial results that we explore in this session: precisely how much purity and reasoning can we bring to the distributed world?
A practical guide to using RxJava on Android. Tips for improving your app architecture with reactive programming. What are the advantages and disadvantages of using RxJava over standard architecture? And how to connect with other popular Android libraries?
Presented at GDG DevFest The Netherlands 2016.
PyCon AU 2012 - Debugging Live Python Web ApplicationsGraham Dumpleton
Monitoring tools record the result of what happened to your web application when a problem arises, but for some classes of problems, monitoring systems are only a starting point. Sometimes it is necessary to take more intrusive steps to plan for the unexpected by embedding mechanisms that will allow you to interact with a live deployed web application and extract even more detailed information.
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1Ihu917.
Jafar Husain shows the Reactive Extensions (Rx) library which allows to treat events as collections, how Netflix uses Rx on the client and the server, allowing to build end-to-end reactive systems. Filmed at qconsf.com.
Jafar Husain developed software for companies like GE, Microsoft, and Netflix. He specializes in building web servers and clients using functional reactive programming, and was the first user of the Reactive Extensions Framework. He's also responsible for "Falkor", a RESTful data access framework that powers most Netflix clients.
.NET Fest 2018. Антон Молдован. One year of using F# in production at SBTechNETFest
В 2017 году мы начали активно использовать F# для построения high-load push-based queryable API, а также обработки больших потоков данных (stateful stream processing). На тот момент времени никто в наших командах не имел предыдущего опыта по внедрению и применению F# но мы решили попробовать. На этом докладе я расскажу о нашем опыте внедрения F#, его проблемах и недостатках, о том как мы его научились готовить, где имеет смысл его применять и как подружить C#/OOP с F#/FP в одном проекте.
Данный доклад нацелен на аудиторию не имеющую предыдущего опыта с FP/F#.
Agenda:
- Why did we choose F# over C#?
- A high-level overview of the architecture of our push-based queryable API.
- Adopting F# for C#/OOP developers (inconveniences, C# interoperability, code style, DDD, TDD)
WebRTC Standards & Implementation Q&A - All about browser interoperabilityAmir Zmora
Hosting guest speaker Jan-Ivar Bruaroey of Mozilla Firefox WebRTC R&D team and contributor to adapter.js talking about Chrome and Firefox interoperability.
The JSON Architecture is a reinvigorating statement for a change in perspective on programming. Tired of fixing bugs, delivering over-budget or past deadlines? The JSON Architecture is a data focused programming paradigm for human centered needs. This leads to massive simplification and reduction of your codebase, easy remodeling of your application regardless of it's maturity and flawless auto-documenting and accelerated handover. The JSON Architecture is a call to a new wave of programmers that need to meet real life challenges and that need to easily adapt to their environment.
Streaming video is not just through Android smartphone and tablet.
The 2014 was the year where Chromecast reached its brightness, getting into 4 millions living rooms. The 2015 instead is the year of the Android TV, the Google way “to smart” the TV.
This talk we’ll give you an overview about the streaming in Android. Starting from video streaming on mobile devices, we will guide you into the evolution of the development through Chromecast up to Android TV.
Matteo Bonifazi and Alessandro Martellucci will be illustrating this talk with their experiences developing mobile television applications for the main Italian broadcaster providers.
In this workshop, you will learn how to build a SwiftUI application with Firebase. We will cover the following topics:
- Data modeling for Firestore
- Efficiently mapping Firestore data using Swift’s Codable protocol
- Fetching data from Firestore using snapshot listeners
- Connecting SwiftUI’s state management system to Firestore to implement real-time sync
- Securing your user’s data using Firebase Security Rules
- Signing in your users using Firebase Authentication
We will be using the latest versions of Firebase and SwiftUI, making use of Combine and async/await to demonstrate how to call asynchronous APIs using modern Swift technologies. Please bring your laptop, making sure to install the latest stable version of Xcode before the workshop.
The unconventional devices for the Android video streamingMatteo Bonifazi
Streaming video is not just through Android smartphone and tablet.
The 2014 was the year where Chromecast reached its brightness, getting into 4 millions living rooms. The 2015 instead is the year of the Android TV, the Google way “to smart” the TV.
This talk we’ll give you an overview about the streaming in Android. Starting from video streaming on mobile devices, we will guide you into the evolution of the development through Chromecast up to Android TV.
Matteo Bonifazi and Alessandro Martellucci will be illustrating this talk with their experiences developing mobile television applications for the main Italian broadcaster providers.
Reactive Programming at Cloud-Scale and BeyondC4Media
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1NAoRFg.
Bart de Smet discusses how the reactive programming paradigm fits the requirements of rich querying capabilities for event streams and can be applied from small devices all the way to cloud-scale infrastructures. Filmed at qconnewyork.com.
Bart de Smet is a Principal Software Development Engineer working on large scale stream processing systems in the Applications and Services Division at Microsoft, a course and book author. In his current role at Microsoft, he’s overseeing the architecture, design, and implementation of event processing systems that run at massive scale in data centers, as well as on cloud-connected devices.
This get started tutorial takes users through the creation of a simple FourSquare clone using the MoSync Reload SDK and cloudbase.io as a backend platform http://cloudbase.io http://www.mosync.com
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/2M35wCo.
Jamund Ferguson talks about some of the challenges PayPal faced with their Node.js application servers and why they think the JAMStack approach improves performance for both their apps and their developers. He includes discussions around performance, security, development experience and deploy speed. Filmed at qconlondon.com.
Jamund Ferguson is a JavaScript architect at PayPal. He loves to look at how following patterns consistently can prevent bugs in applications. He’s previously contributed to the ESLint and StandardJS open-source projects and has as of late become a fan of FlowType and TypeScript.
To view recording of this webinar please use below URL
http://wso2.com/library/webinars/2015/11/wso2-product-release-webinar-wso2-complex-event-processor-4.0/
In this webinar, Lasantha and Suho will discuss the following key features and improvements in detail:
Integrating WSO2 CEP with Apache Storm to achieve distributed real-time stream processing
Key features of the latest version of Siddhi
New transports that enhances integration capabilities of WSO2 CEP
Creating query templates using execution manager
Using the analytics dashboard to visualize results in real-time
Digital Publishing for Scale: The Economist and GoC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2CALlGE.
Kathryn Jonas talks about The Economist’s struggles and victories in transitioning to Go and how Go has uniquely fit their digital publishing goals. Filmed at qconnewyork.com.
Kathryn Jonas is the Lead Engineer for the Content Platform at The Economist. She has lead projects for organizations in Beijing, London, and New York, applying technology to diverse challenges such as mission impact evaluation, editorial transparency and trust, and online learning and collaboration.
Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients. AND IT'S TRUE!
In this talk given at JBCNConf 2015 in Barcelona, we will see how we use Netty at Trovit since 2013, what brought to us and how it opened our minds. We will share tips that helped us to learn more about Netty, some performance tricks and all things that worked for us.
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/2suQXL2.
Armin Ronacher shares his experiences building SaaS businesses on a Python technology stack from a security and scalability point of view, where Python shines and which technologies to pair it with for best experiences. Filmed at qconlondon.com.
Armin Ronacher is the creator of the Python Flask framework and frequent speaker at conferences about API and system design. He is currently working on Sentry, an Open Source Crash Reporting SaaS business.
Streaming a Million Likes/Second: Real-Time Interactions on Live VideoC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/39NIjLV.
Akhilesh Gupta does a technical deep-dive into how Linkedin uses the Play/Akka Framework and a scalable distributed system to enable live interactions like likes/comments at massive scale at extremely low costs across multiple data centers. Filmed at qconlondon.com.
Akhilesh Gupta is the technical lead for LinkedIn's Real-time delivery infrastructure and LinkedIn Messaging. He has been working on the revamp of LinkedIn’s offerings to instant, real-time experiences. Before this, he was the head of engineering for the Ride Experience program at Uber Technologies in San Francisco.
Next Generation Client APIs in Envoy MobileC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2x0Fav8.
Jose Nino guides the audience through the journey of Mobile APIs at Lyft. He focuses on how the team has reaped the benefits of API generation to experiment with the network transport layer. He also discusses recent developments the team has made with Envoy Mobile and the roadmap ahead. Filmed at qconlondon.com.
Jose Nino works as a Software Engineer at Lyft.
Software Teams and Teamwork Trends Report Q1 2020C4Media
How do we cope with an environment that has been radically disrupted, where people are suddenly thrust into remote work in a chaotic state? What are the emerging good practices and new ideas that are shaping the way in which software development teams work? What can we do to make the workplace a more secure and diverse one while increasing the productivity of our teams? This report aims to assist technical leaders in making mid- to long-term decisions that will have a positive impact on their organisations and teams and help individual contributors find the practices, approaches, tools, techniques, and frameworks that can help them get a better experience at work - irrespective of where they are working from.
Understand the Trade-offs Using Compilers for Java ApplicationsC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2QCmmJ0.
Mark Stoodley examines some of the strengths and weaknesses of the different Java compilation technologies, if one was to apply them in isolation. Stoodley discusses how production JVMs are assembling a combination of these tools that work together to provide excellent performance across the large spectrum of applications written in Java and JVM based languages. Filmed at qconsf.com.
Mark Stoodley joined IBM Canada to build Java JIT compilers for production use and led the team that delivered AOT compilation in the IBM SDK for Java 6. He spent the last five years leading the effort to open source nearly 4.3 million lines of source code from the IBM J9 Java Virtual Machine to create the two open source projects Eclipse OMR and Eclipse OpenJ9, and now co-leads both projects.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2y2yPiS.
Colin McCabe talks about the ongoing effort to replace the use of Zookeeper in Kafka: why they want to do it and how it will work. He discusses the limitations they have found and how Kafka benefits both in terms of stability and scalability by bringing consensus in house. He talks about their progress, what work is remaining, and how contributors can help. Filmed at qconsf.com.
Colin McCabe is a Kafka committer at Confluent, working on the scalability and extensibility of Kafka. Previously, he worked on the Hadoop Distributed Filesystem and the Ceph Filesystem.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2SXXXiD.
Katharina Probst talks about what it means to act like an owner and why teams need ownership to be high-performing. When team members, regardless of whether they have a formal leadership role or not, act like owners, magical things can happen. She shares ideas that we can apply to our own work, and talks about how to recognize when we don’t live up to our own expectations of acting like an owner. Filmed at qconsf.com.
Katharina Probst is a Senior Engineering Leader, Kubernetes & SaaS at Google. Before this, she was leading engineering teams at Netflix, being responsible for the Netflix API, which helps bring Netflix streaming to millions of people around the world. Prior to joining Netflix, she was in the cloud computing team at Google, where she saw cloud computing from the provider side.
Does Java Need Inline Types? What Project Valhalla Can Bring to JavaC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2T04Lw4.
Sergey Kuksenko talks about the performance benefits inline types bring to Java and how to exploit them. Inline/value types are the key part of experimental project Valhalla, which should bring new abilities to the Java language. Filmed at qconsf.com.
Sergey Kuksenko is a Java Performance Engineer at Oracle working on a variety of Java and JVM performance enhancements. He started working as Java Engineer in 1996 and as Java Performance Engineer in 2005. He has had a passion for exploring how Java works on modern hardware.
Do you need service meshes in your tech stack?
This on-line guide aims to answer pertinent questions for software architects and technical leaders, such as: what is a service mesh?, do I need a service mesh?, how do I evaluate the different service mesh offerings? In software architecture, a service mesh is a dedicated infrastructure layer for facilitating service-to-service communications between microservices, often using a sidecar proxy.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2UgQ3BU.
Christie Wilson describes what to expect from CI/CD in 2019, and how Tekton is helping bring that to as many tools as possible, such as Jenkins X and Prow. Wilson talks about Tekton itself and performs a live demo that shows how cloud native CI/CD can help debug, surface and fix mistakes faster. Filmed at qconsf.com.
Christie Wilson is a software engineer at Google, currently leading the Tekton project. Over the past decade, she has worked in the mobile, financial and video game industries. Prior to working at Google she led a team of software developers to build load testing tools for AAA video game titles, and founded the Vancouver chapter of PyLadies.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2S7lDiS.
Sasha Rosenbaum shows how a CI/CD pipeline for Machine Learning can greatly improve both productivity and reliability. Filmed at qconsf.com.
Sasha Rosenbaum is a Program Manager on the Azure DevOps engineering team, focused on improving the alignment of the product with open source software. She is a co-organizer of the DevOps Days Chicago and the DeliveryConf conferences, and recently published a book on Serverless computing in Azure with .NET.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/36epVKg.
Todd Montgomery discusses the techniques and lessons learned from implementing Aeron Cluster. His focus is on how Raft can be implemented on Aeron, minimizing the network round trip overhead, and comparing single process to a fully distributed cluster. Filmed at qconsf.com.
Todd Montgomery is a networking hacker who has researched, designed, and built numerous protocols, messaging-oriented middleware systems, and real-time data systems, done research for NASA, contributed to the IETF and IEEE, and co-founded two startups. He currently works as an independent consultant and is active in several open source projects.
Architectures That Scale Deep - Regaining Control in Deep SystemsC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2FWc5Sk.
Ben Sigelman talks about "Deep Systems", their common properties and re-introduces the fundamentals of control theory from the 1960s, including the original conceptualizations of Observability & Controllability. He uses examples from Google & other companies to illustrate how deep systems have damaged people's ability to observe software, and what needs to be done in order to regain control. Filmed at qconsf.com.
Ben Sigelman is a co-founder and the CEO at LightStep, a co-creator of Dapper (Google’s distributed tracing system), and co-creator of the OpenTracing and OpenTelemetry projects (both part of the CNCF). His work and interests gravitate towards observability, especially where microservices, high transaction volumes, and large engineering organizations are involved.
ML in the Browser: Interactive Experiences with Tensorflow.jsC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/39SddUL.
Victor Dibia provides a friendly introduction to machine learning, covers concrete steps on how front-end developers can create their own ML models and deploy them as part of web applications. He discusses his experience building Handtrack.js - a library for prototyping real time hand tracking interactions in the browser. Filmed at qconsf.com.
Victor Dibia is a Research Engineer with Cloudera’s Fast Forward Labs. Prior to this, he was a Research Staff Member at the IBM TJ Watson Research Center, New York. His research interests are at the intersection of human computer interaction, computational social science, and applied AI.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2s9T3Vl.
Colin Eberhardt looks at some of the internals of WebAssembly, explores how it works “under the hood”, and looks at how to create a (simple) compiler that targets this runtime. Filmed at qconsf.com.
Colin Eberhardt is the Technology Director at Scott Logic, a UK-based software consultancy where they create complex application for their financial services clients. He is an avid technology enthusiast, spending his evenings contributing to open source projects, writing blog posts and learning as much as he can.
User & Device Identity for Microservices @ Netflix ScaleC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2S9tOgy.
Satyajit Thadeshwar provides useful insights on how Netflix implemented a secure, token-agnostic, identity solution that works with services operating at a massive scale. He shares some of the lessons learned from this process, both from architectural diagrams and code. Filmed at qconsf.com.
Satyajit Thadeshwar is an engineer on the Product Edge Access Services team at Netflix, where he works on some of the most critical services focusing on user and device authentication. He has more than a decade of experience building fault-tolerant and highly scalable, distributed systems.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2Ezs08q.
Justin Ryan talks about Netflix’ scalability issues and some of the ways they addressed it. He shares successes they’ve had from unintuitively partitioning computation into multiple services to get better runtime characteristics. He introduces us to useful probabilistic data structures, innovative bi-directional data passing, open-source projects available from Netflix that make this all possible. Filmed at qconsf.com.
Justin Ryan is Playback Edge Engineering at Netflix. He works on some of the most critical services at Netflix, specifically focusing on user and device authentication. Years of building developer tools has also given him a healthy set of opinions on developer productivity.
Make Your Electron App Feel at Home EverywhereC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2Z4ZJjn.
Kilian Valkhof discusses the process of making an Electron app feel at home on all three platforms: Windows, MacOS and Linux, making devs aware of the pitfalls and how to avoid them. Filmed at qconsf.com.
Kilian Valkhof is a Front-end Developer & User-experience Designer at Firstversionist. He writes about various topics, from design to machine learning, on his personal website, kilianvalkhof.com and is a frequent contributer to open source software. He is part of the Electron governance team that oversees the development of the Electron framework.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/344PnB1.
Steve Klabnik goes over the deep details of how async/await works in Rust, covering concepts like coroutines, generators, stack-less vs stack-ful, "pinning", and more. Filmed at qconsf.com.
Steve Klabnik is on the core team of Rust, leads the documentation team, and is an author of "The Rust Programming Language." He is a frequent speaker at conferences and is a prolific open source contributor, previously working on projects such as Ruby and Ruby on Rails.
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2OUz6dt.
Chris Riccomini talks about the current state-of-the-art in data pipelines and data warehousing, and shares some of the solutions to current problems dealing with data streaming and warehousing. Filmed at qconsf.com.
Chris Riccomini works as a Software Engineer at WePay.
Automated Testing for Terraform, Docker, Packer, Kubernetes, and MoreC4Media
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2rm4hFD.
Yevgeniy Brikman talks about how to write automated tests for infrastructure code, including the code written for use with tools such as Terraform, Docker, Packer, and Kubernetes. Topics covered include: unit tests, integration tests, end-to-end tests, dependency injection, test parallelism, retries and error handling, static analysis, property testing and CI / CD for infrastructure code. Filmed at qconsf.com.
Yevgeniy Brikman is the co-founder of Gruntwork, a company that provides DevOps as a Service. He is the author of two books published by O'Reilly Media: Hello, Startup and Terraform: Up & Running. Previously, he worked as a software engineer at LinkedIn, TripAdvisor, Cisco Systems, and Thomson Financial.
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
In his public lecture, Christian Timmerer provides insights into the fascinating history of video streaming, starting from its humble beginnings before YouTube to the groundbreaking technologies that now dominate platforms like Netflix and ORF ON. Timmerer also presents provocative contributions of his own that have significantly influenced the industry. He concludes by looking at future challenges and invites the audience to join in a discussion.
State of ICS and IoT Cyber Threat Landscape Report 2024 previewPrayukth K V
The IoT and OT threat landscape report has been prepared by the Threat Research Team at Sectrio using data from Sectrio, cyber threat intelligence farming facilities spread across over 85 cities around the world. In addition, Sectrio also runs AI-based advanced threat and payload engagement facilities that serve as sinks to attract and engage sophisticated threat actors, and newer malware including new variants and latent threats that are at an earlier stage of development.
The latest edition of the OT/ICS and IoT security Threat Landscape Report 2024 also covers:
State of global ICS asset and network exposure
Sectoral targets and attacks as well as the cost of ransom
Global APT activity, AI usage, actor and tactic profiles, and implications
Rise in volumes of AI-powered cyberattacks
Major cyber events in 2024
Malware and malicious payload trends
Cyberattack types and targets
Vulnerability exploit attempts on CVEs
Attacks on counties – USA
Expansion of bot farms – how, where, and why
In-depth analysis of the cyber threat landscape across North America, South America, Europe, APAC, and the Middle East
Why are attacks on smart factories rising?
Cyber risk predictions
Axis of attacks – Europe
Systemic attacks in the Middle East
Download the full report from here:
https://sectrio.com/resources/ot-threat-landscape-reports/sectrio-releases-ot-ics-and-iot-security-threat-landscape-report-2024/
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
Monitoring Java Application Security with JDK Tools and JFR Events
Reactive Programming with Rx
1. Ben Christensen
Developer – Edge Engineering at Netflix
@benjchristensen
http://techblog.netflix.com/
QConSF - November 2014
ReactiveProgrammingwithRx
2. InfoQ.com: News & Community Site
• 750,000 unique visitors/month
• Published in 4 languages (English, Chinese, Japanese and Brazilian
Portuguese)
• Post content from our QCon conferences
• News 15-20 / week
• Articles 3-4 / week
• Presentations (videos) 12-15 / week
• Interviews 2-3 / week
• Books 1 / month
Watch the video with slide
synchronization on InfoQ.com!
http://www.infoq.com/presentations
/rx-service-architecture
3. Purpose of QCon
- to empower software development by facilitating the spread of
knowledge and innovation
Strategy
- practitioner-driven conference designed for YOU: influencers of
change and innovation in your teams
- speakers and topics driving the evolution and innovation
- connecting and catalyzing the influencers and innovators
Highlights
- attended by more than 12,000 delegates since 2007
- held in 9 cities worldwide
Presented at QCon San Francisco
www.qconsf.com
21. // infinite
Observable.create(subscriber -> {
int i=0;
while(!subscriber.isUnsubscribed()) {
subscriber.onNext(i++);
}
}).subscribe(System.out::println);
Note: No backpressure support here. See Observable.from(Iterable)
or Observable.range() for actual implementations
22. Hot Cold
emits whether you’re ready or not
examples
mouse and keyboard events
system events
stock prices
emits when requested
(generally at controlled rate)
examples
database query
web service request
reading file
Observable.create(subscriber -> {
// register with data source
})
Observable.create(subscriber -> {
// fetch data
})
23. Hot Cold
emits whether you’re ready or not
examples
mouse and keyboard events
system events
stock prices
emits when requested
(generally at controlled rate)
examples
database query
web service request
reading file
Observable.create(subscriber -> {
// register with data source
})
Observable.create(subscriber -> {
// fetch data
})
flow control flow control & backpressure
29. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
30. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
31. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
32. Observable<R>
b
=
Observable<T>.flatMap({
T
t
-‐>
Observable<R>
r
=
...
transform
t
...
return
r;
})
flatMap
33. Observable<R>
b
=
Observable<T>.flatMap({
T
t
-‐>
Observable<R>
r
=
...
transform
t
...
return
r;
})
flatMap
34. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
35. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
36. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
37. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
38. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
39. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
40. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
41. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
42. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
43. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
44. Observable.zip(a,
b,
(a,
b)
-‐>
{
...
operate
on
values
from
both
a
&
b
...
return
Arrays.asList(a,
b);
})
zip { ( , ) }
45. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
46. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
47.
48. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
49. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
55. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
56.
57.
58.
59.
60. public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
}).flatMap(data -> {
// output as SSE as we get back the data (no waiting until all is done)
return response.writeAndFlush(new ServerSentEvent(SimpleJson.mapToJson(data)));
});
}
61.
62. Decouples Consumption from Production
// first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
})
63. // first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
})
Decouples Consumption from Production
64. // first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
})
Decouples Consumption from Production
65. Decouples Consumption from Production
Event Loop
API Request
API Request
API Request
API Request
API Request
Dependency
REST API
new Command().observe()
new Command(). observe()
new Command(). observe()
new Command(). observe()
new Command(). observe()
Collapser
66. // first request User object
return getUser(request.getQueryParameters().get("userId")).flatMap(user -> {
// then fetch personal catalog
Observable<Map<String, Object>> catalog = getPersonalizedCatalog(user)
.flatMap(catalogList -> {
return catalogList.videos().<Map<String, Object>> flatMap(video -> {
Observable<Bookmark> bookmark = getBookmark(video);
Observable<Rating> rating = getRating(video);
Observable<VideoMetadata> metadata = getMetadata(video);
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> {
return combineVideoData(video, b, r, m);
});
});
});
// and fetch social data in parallel
Observable<Map<String, Object>> social = getSocialData(user).map(s -> {
return s.getDataAsMap();
});
// merge the results
return Observable.merge(catalog, social);
})
~5 network calls
(#3 and #4 may result in more due to windowing)
1
2
3
4
5
80. Concurrency
an Observable is sequential
(no concurrent emissions)
scheduling and combining Observables
enables concurrency while retaining sequential emission
81. // merging async Observables allows each
// to execute concurrently
Observable.merge(getDataAsync(1), getDataAsync(2))
merge
82. // concurrently fetch data for 5 items
Observable.range(0, 5).flatMap(i -> {
return getDataAsync(i);
})
92. Hot Cold
emits whether you’re ready or not
examples
mouse and keyboard events
system events
stock prices
emits when requested
(generally at controlled rate)
examples
database query
web service request
reading file
Observable.create(subscriber -> {
// register with data source
})
Observable.create(subscriber -> {
// fetch data
})
flow control flow control & backpressure
100. /* The following will emit a buffered list as it is debounced */
// first we multicast the stream ... using refCount so it handles the subscribe/unsubscribe
Observable<Integer> burstStream = intermittentBursts().take(20).publish().refCount();
// then we get the debounced version
Observable<Integer> debounced = burstStream.debounce(10, TimeUnit.MILLISECONDS);
// then the buffered one that uses the debounced stream to demark window start/stop
Observable<List<Integer>> buffered = burstStream.buffer(debounced);
// then we subscribe to the buffered stream so it does what we want
buffered.toBlocking().forEach(System.out::println);
[0, 1, 2]
[0, 1, 2]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4]
[0, 1]
[]
101. /* The following will emit a buffered list as it is debounced */
// first we multicast the stream ... using refCount so it handles the subscribe/unsubscribe
Observable<Integer> burstStream = intermittentBursts().take(20).publish().refCount();
// then we get the debounced version
Observable<Integer> debounced = burstStream.debounce(10, TimeUnit.MILLISECONDS);
// then the buffered one that uses the debounced stream to demark window start/stop
Observable<List<Integer>> buffered = burstStream.buffer(debounced);
// then we subscribe to the buffered stream so it does what we want
buffered.toBlocking().forEach(System.out::println);
[0, 1, 2]
[0, 1, 2]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4]
[0, 1]
[]
102. /* The following will emit a buffered list as it is debounced */
// first we multicast the stream ... using refCount so it handles the subscribe/unsubscribe
Observable<Integer> burstStream = intermittentBursts().take(20).publish().refCount();
// then we get the debounced version
Observable<Integer> debounced = burstStream.debounce(10, TimeUnit.MILLISECONDS);
// then the buffered one that uses the debounced stream to demark window start/stop
Observable<List<Integer>> buffered = burstStream.buffer(debounced);
// then we subscribe to the buffered stream so it does what we want
buffered.toBlocking().forEach(System.out::println);
[0, 1, 2]
[0, 1, 2]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4]
[0, 1]
[]
103. /* The following will emit a buffered list as it is debounced */
// first we multicast the stream ... using refCount so it handles the subscribe/unsubscribe
Observable<Integer> burstStream = intermittentBursts().take(20).publish().refCount();
// then we get the debounced version
Observable<Integer> debounced = burstStream.debounce(10, TimeUnit.MILLISECONDS);
// then the buffered one that uses the debounced stream to demark window start/stop
Observable<List<Integer>> buffered = burstStream.buffer(debounced);
// then we subscribe to the buffered stream so it does what we want
buffered.toBlocking().forEach(System.out::println);
[0, 1, 2]
[0, 1, 2]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4]
[0, 1]
[]
104. /* The following will emit a buffered list as it is debounced */
// first we multicast the stream ... using refCount so it handles the subscribe/unsubscribe
Observable<Integer> burstStream = intermittentBursts().take(20).publish().refCount();
// then we get the debounced version
Observable<Integer> debounced = burstStream.debounce(10, TimeUnit.MILLISECONDS);
// then the buffered one that uses the debounced stream to demark window start/stop
Observable<List<Integer>> buffered = burstStream.buffer(debounced);
// then we subscribe to the buffered stream so it does what we want
buffered.toBlocking().forEach(System.out::println);
[0, 1, 2]
[0, 1, 2]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4]
[0, 1]
[]
105. /* The following will emit a buffered list as it is debounced */
// first we multicast the stream ... using refCount so it handles the subscribe/unsubscribe
Observable<Integer> burstStream = intermittentBursts().take(20).publish().refCount();
// then we get the debounced version
Observable<Integer> debounced = burstStream.debounce(10, TimeUnit.MILLISECONDS);
// then the buffered one that uses the debounced stream to demark window start/stop
Observable<List<Integer>> buffered = burstStream.buffer(debounced);
// then we subscribe to the buffered stream so it does what we want
buffered.toBlocking().forEach(System.out::println);
[0, 1, 2]
[0, 1, 2]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4]
[0, 1]
[]
https://gist.github.com/benjchristensen/e4524a308456f3c21c0b
109. Push (reactive) when consumer
keeps up with producer.
Switch to Pull (interactive)
when consumer is slow.
Bound all* queues.
110. *vertically, not horizontally
Push (reactive) when consumer
keeps up with producer.
Switch to Pull (interactive)
when consumer is slow.
Bound all* queues.
177. Reactive Programming in the Netflix API with RxJava http://techblog.netflix.com/2013/02/rxjava-netflix-api.html
Optimizing the Netflix API http://techblog.netflix.com/2013/01/optimizing-netflix-api.html
Reactive Extensions (Rx) http://www.reactivex.io
Reactive Streams https://github.com/reactive-streams/reactive-streams
Ben Christensen
@benjchristensen
RxJava
https://github.com/ReactiveX/RxJava
@RxJava
RxJS
http://reactive-extensions.github.io/RxJS/
@ReactiveX
jobs.netflix.com
178. Watch the video with slide synchronization on
InfoQ.com!
http://www.infoq.com/presentations/rx-
service-architecture