At PDC a few years back, we introduced the Language Integrated Query project to solve the impedance mismatch between various data models by means of integrated query syntax in mainstream programming languages. Today, we’re seeing a rich ecosystem around LINQ providers that allow developers to reach out to many more data models. While LINQ focused mainly on bridging the gaps between object-oriented programming, relational databases, and XML, there’s a lot of opportunity left to democratize querying over even more data models. In this talk, we have a look at how we can “LINQ to the unexpected”.

Based on the theory of monads, we’ll explore the incredibly powerful nature of query comprehensions to do things like theorem and constraint solving, build reactive event-processing queries (cf. Reactive Extensions for .NET), carry out various forms of query optimization, split execution of queries across tiers using expression tree serialization techniques, etc. In addition, we revisit the art of writing query providers, introducing some novel approaches to ensure better compile-time checking and an improved developer experience. After this talk, you’ll truly understand the (underestimated) power that LINQ has brought us.

Event-driven "reactive" programming is way too hard with today's development frameworks. The staggering amount of manual and error-prone plumbing needed to compose event sources leads to incomprehensible and hard to maintain code. As we reach out to services in the cloud, mobile programming, etc. the desire for event-oriented (asynchronous) computation is ever increasing, requiring a fresh look on the problems imposed by reactive programming. Centered around the concept of observable sequences, Rx provides a framework that takes care of the hard parts of programming event-processing systems. Instead of getting lost in the jungle of hand-crafted callbacks, you now can start dreaming about the endless possibilities of composing queries over asynchronous data sources, piggybacking on convenient LINQ syntax.

In this session, we'll cover the design philosophy of Rx, rooted in a deep connection between the pull-based (synchronous and “interactive”) IEnumerable interface and the new push-based (asynchronous and “reactive”) IObservable interface. From this core understanding, we'll start looking at exposing existing event sources through the lenses of observable sequences. Next, we explore various query operators defined over observable sequences, driving concepts home by a bunch of samples. In passing, we also get to know Rx’s abstraction for introducing concurrency, known as IScheduler. Finally, we’ll have a look at the “async” and “await” features slated for the next version of C# and VB, and explain how those relate to asynchronous programming with Rx.