 This session is about reactive streams. And I'll introduce myself. I'm Mushtaq. I'm from ThoughtWorks Pune office. And I'm a big Scala enthusiast. I like to teach Scala and talk about Scala. And we are doing Scala projects in ThoughtWorks Pune a lot for the past four years. So I'm driving, evangelizing that internally. About reactive streams, I mean, what is the familiarity? I mean, have you heard of reactive streams? And some familiarity, reactive streams? OK, so I'll start with basics, right? So this work is we are doing a prototype. We are doing a prototype for a customer. It's going to be open source eventually. So that's why I can share this. And while doing that, we used our custom streams and stuff like that. At that point, I learned, personally I learned that how interesting it becomes the moment you start using lazy streams or collections, right? So far, I have been using, I mean, past four years I have been using Scala collections. How many of you are family with Scala? And have you Scala, to some extent, just some try? So Scala, if you Scala use Scala collections like every other minute, you are writing something using a Scala collection. And that model is very simple, but very powerful. What you do is, for example, there is a disk or a source somewhere with data. The first linear graph says that if you want to just process that data, what do you do? You first read it. And then the three cells, they represent that, OK, data has come in memory. So it's as simple as that and as dumb as that, right? So it's in memory collections. And then you do further processing like square, all the numbers, map dot map square. And you get yet another collection in memory, right? So that is how it works. And then finally, you say take two. And then you get the first two elements, again, yet another collection in memory. And then these collections are immutable, which is good, because then they can be freely shared. And we'll see that in the next graph, right? How sharing is easy and possible. But in memory collections have a limitation, right? I think if my file is any decent file of size, say, 1GB, and I can't do this kind of a processing, so I have to use a different way of processing, not the Scala collections in memory collections. They also, at each point, they also allocate a new, I think it's, can you please reduce a little? It also allocates a new set of collection after each processing, right? So if you have many steps, then there is a lot of garbage which is produced. Another argument is that maybe because you're producing, you have to iterate over each element. So for example,