 Okay. My name is Colin. I'm from Microsoft Research in Cambridge. I'm just going to start with a bit of a story because I think it's a kind of interesting case of open source being quite a win, so this is the kind of conference for it. So a few years ago, one of my colleagues came to me and explained that he was a bit sad. I was a bit worried because he programs in Python, and we mostly program in .NET, and I thought maybe he's not getting on with types, and the language, and this would be challenging because working with the rest of my colleagues. But it actually turns out, his issue was it was kind of a way of working, because as well as programming, he's also primarily a scientist, and one of the things he used a lot is IPython notebooks, and so rather than being a language, it was a way of working, and so we went into the search, and we fortunately found out on kind of healthy open source ecosystem in .NET, there was a project called IF-Sharp, which this was a project that was taking the F-Sharp language and making it available in what is now called Jupyter notebooks. At the time, it was more exclusively focused on Python, but it's been a kind of a refactoring and re-jigging of the community so that a lot more languages, and so after quite a long story, and I very much appreciate the people who made this available, I've now ended up as one of the primary maintainers of this library, which means you can give back to the community as well. So what was my colleague talking about? Like what kind of things did he want to do? So this notebook system is a way of creating an interplay between text and description, data, and the code that you might operate on it. Now, why might that be important? Now, especially in a kind of scientific community or an explanation community, so for education, then you really want to enable the explanations for what's happening to go alongside the code, because it helps you with keeping it working, it helps you with being able to show with your colleagues. So another person I work with is a guy called Ben Hall at Cambridge, and he teaches undergraduates, and one of the things he's doing is teaching like how to model Brownian motion in bacterial cells and how they move about, and so he's built a notebook using the F-sharp notebook system, and we've got here like some text, which you can edit in markdown, but as well he has some F-sharp down at the bottom here. So what he's doing here is starting to set up the units, the system, the things he's going to work with to provide an implementation, so he can run simulations over this. But it's all in an environment together, and just to show that, then you can jump to the markdown form of that as well as seeing the rendered text. All the details of this is like I don't need to worry about. It's more that if you have some explanation that you want to pass along with a code, you could put it in text, but it then might be quite hard if as Ben's doing here, you want to write some latex and you want fully rendered mathematics, which is what you can get back to. So you have this form where you're seeing the results as well as convenient editing environment. Now we go even further as well, as well as the code and the explanation. He's also able to run a simulation in the notebook environment and then visualize the results. This really helps for if you don't really know exactly what's happening with the data, or you want to explore or understand, this is a way to interact with programming. So this goes even further. I just have to mention this is from the Python space, but there's no Python notebook from the gravity wave experiments, where not only do they have some output, they're actually an output of sound from some of the analysis, and as the notes are saying, you put on headphones and if this was a real notebook, you could click it and there's a little bump in the middle there which you can listen to. It's kind of cool to be able to take like cutting-edge research, take their data and understanding and have a form that you can easily reproduce, which often isn't the case with a lot of scientific software. And here's another example of like moving into the community as well. There's another person I work with remotely on so-called probabilistic programming. So this is taking F-sharp and a very useful library called for differential programming. So, and one here as well. So this is some of my own research that I work with scientists on understanding stem cells in mice and in the future in humans as well. And so again, what we're doing is mixing these explanations, these model, these codes that's available, and then the renderings of those. Now this is a very cool example that's very recently, that not only are you producing static outputs, but there's a guy called Jason Pedaris, I hope I'm saying his name correctly, who's taken the CNTK deep learning toolkit and put it into an environment where you can model, explore, and clean the data. But he's also used a new feature for asynchronous programming. So this is a bit like async in both C-sharp and TypeScript, but F-sharp's got a slightly different take on it and we're building this sequence and then we're rendering it through to the front end. So you're able to see your deep learning model training as you're running. Now obviously at some point, you want to scale up to a lot more GPUs on clouds or elsewhere, but when you're doing that initial stage of seeing if the model's feasible, it's really useful to get rapid feedback. Okay, so fully open source projects, runs on Linux, Mac, Windows, running on Mac here, just one of the places. What I want to do is show you a little bit of what's going on here. A lot of this, I'm not going to run in too much detail because I don't want to rely on the Wi-Fi and some of it's fetching external packages, but I've provided like a whole series of samples and these samples are up and available and accessible so you can search and run these yourself as well. So just to get started, so I've criss-covered earlier like some basics of F-sharp, but just to show you some of the things you can kind of do. So you're writing F-sharp here and these are the outputs immediately afterwards. So it's taking the last expression and printing it out. It's not super exciting, but just to show that the system's basically working. So we've got a more detailed samples as well and again, what we're doing here is providing our links to more information, but then giving people context with the code. So it's really useful as a kind of getting started environment. So it gives you some context just to demonstrate that this isn't all fakery. If I alter this slightly, we get a much different number. And so one way to think about this and so from people who are programming perspective is that there's a kind of a repel underneath this. And so we are actually literally using the F-sharp interactive service and so people are familiar with C-sharp. There's a similar one there now as well. Or it's just kind of equivalent to your browser console. Now we're using a quite convenient library that was made available, which is the F-sharp compiler services. So this idea of F-sharp as a service. And so what we're doing is we're taking this code at the front end, we're piping it over ZMQ, the .NET implementation, from the front end to a server. It's taking that code, compiling and executing it on the fly. Now the reason why that's important is that as we're a repel, then you have stays underneath this as well. So when you get a single output back, we're not just throwing everything away. So we've got some code here and it's a very trivial function again. But in the other cells, you still have that same context. So there's a system running underneath. So you can build up interesting data or things that take perhaps a kind of non-trivial amount of time to execute and then work with them in a different way. So if you compare it to having to write scripts, this allows you to do this much more exploratory interactive approach. And so there's a whole series of things here, like just kind of getting started with F-sharp, which all this is available if you wanted to as a way of learning. This is an example of using these kind of units of measure, which allows you to tag information into the numbers you're passing around. This is the kind of thing that if different people use this, less rockets would crash into Mars because we wouldn't have so many unit mix-ups. And so, okay, that's all the basics. Like you could do this in a lot of environments. It's not much different from a kind of classical repel. Once it starts, where it starts getting interesting is if you wanna start using additional external code. So, not only can you use libraries that are kind of built into the compiler, you might also have your own setup. So what I'm doing here is basically trying to access a bit of the .NET framework. It's not currently referenced. So as well as giving certain text highlighting, we're actually giving kind of full error completion in here. So you can actually start referencing extra DLLs so you have more functionality. What I'm gonna do, though, is rather than doing it kind of this ad hoc way of pointing to your local DLLs, some library that you've made, then it's really useful to be able to pull in libraries from NuGet. And so this is a package manager called Packet. It's kind of a front-end client around NuGet. And we've brought it into here with a bit of a small DSL. So what we're saying here is if we pull in the library, FSLab, which is a series of kind of scientifically useful libraries, a bit analogous to Matlab. And what we're doing here is specifying the version because I'm being precise about what we're depending on so my demos won't blow up. What we've done is we can then pull down that library. But just to show you the stuff underneath, like pull back the layer a little bit, it's just all F-sharp code in here. It's just showing you basically we can build up these layers and we could use this externally. So things that you prototype in a notebook when you say some data scientists that you work with showed some working algorithm. It'd be much easier to move out of here than to say you've been working in Matlab or another kind of rapid prototyping or statistics environment. And so we've pulled in this library and what we can start doing is I'm gonna just code in some like a really simple example. So what this is showing is a series of dates and values and this might be a time series, maybe it comes from an instrument. And when you run this, it automatically takes the last expression and what this is doing is forward-mining out here. This isn't very convenient. It's not really useful for a lot of people to look at and help them understand. And so what we can do, and this is a feature that was worked on by some of our collaborators in Moscow State University, a program called Lucy. She's made it so that you can also use this to ask Packet to bring you down some code from GitHub. So there's a repository by somebody in the community who's built some extensions. And what you could do is go and manually download those F-sharp files yourself. Put them on the desk, but then you've got to worry about paths and locations and keep your things up to date. And I should mention just while I'm here, then you can pin it to an exact version. What I'm running here is it's literally, it would literally pull down the version on GitHub. Somebody could change it underneath your feet and surprising things might happen. What you're then able to do is you pull down this file from GitHub. You can then load it on the fly into the interactive environment using this. So we're looking into the packet files and that's the package manager that's brought down this. Then we're able to load up that formatting code. And what it's done is registered itself with the Jupyter Notebook system and said, when you have types that look like the outputs of that data, instead substitute in this extra code. Now a lot of that's written in JavaScript because this front-end is primarily a web browser and that's a good way to get it done. But you're shielded from that, so one person can build a visualizer and then other people can start making use of it. And so, similarly, you might not want to hard-code in your data as I've demonstrated here. You might have some CSV files and so this is a library for data frames and that's quite a convenient way of working with gridded data. That it'll automatically read out things like column headings. And so it's just warning here a little bit about it claims we shouldn't use it from F sharp, but it's totally fine. And if you pass in a little bit more information, the warning will go away as well. So okay, we've got a way of pulling in external packages, useful functionality. We've got a way of customizing what we see and how it interacts. We want to make it a little bit more, well, probably just a little bit more fancy. And so there's a very useful library called xplot. This is an F sharp or .NET in general, wrapper onto the plotly library which is written in JavaScript but it's generally available and it's also used in Python. So what we can do is then open up this external library and we've got this very kind of trivial example of plotting some numbers. One of the things just to highlight is again how convenient a lot of this is that we've not had to do a lot of restructuring. We're just saying we're passing into this function that turns things into bar charts. We've got some customization and then what you get out is actually a kind of fully interactive visualization. And so in this case, it's not too hard to see what these numbers are but you can also move around in this environment and pull it up into the plotly system as well if you wanted to do so. This is all running locally. You're not having to send your data to the remote servers which is very kindly made as available again and never strong contribution and coordination in the open source space. And so one thing just to be aware of when you're working in this environment is that what I've done here is I've copied it twice. Let's say you wanted two different charts, you wanted to look at them side by side. One of the things to be aware of is that what we're doing is pulling out the last expression. So what this will do is when this second one is drawn it'll pull out that and plot that but it'll discard the other one. So just a kind of thing to be aware of. If you want to plot lots of things, if you want to kind of do IO, you need to be saying push that out to the console or push it out to the graphics context. And again, I think I've got this up. Yeah, so we don't want to have this do an environment where you have to build everything from scratch because you then end up with a, and I've seen this happen a lot, one tool that's used by the scientist, one tool that's used by the programmers and you have a very hard time transferring like new analysis methods, new research into tools that you might make available externally. And so this is just this standard documentation and this documentation was never written with anticipating being used in this kind of notebook context but you can still take the examples that the people who've built here and drag them over into a notebook context. And so I'm not going to go over all this code in detail just because it's quite involved but you're starting to get from quite rich visualizations. And if you start to think about how you might be able to make something like this available so like the people in your environment who would otherwise resort to writing our code or other statistical environment, you might be able to collaborate more on the code to understand what's happening and then you might be able to make those more easily available. And that's one of the things we found very helpful. Sorry, trying to check the time. Okay, so there's also the thing I'm showing here is just for Google charts. We don't, in a sense, play favorites. We've added some helper libraries so they can connect to the different charting libraries but Plotly and Google charts. Now, I was saying about interactive charts. Now it's very static there. You can hover over it. So in a sense it's interactive in that you've got all the information there and you can see it in different ways. There's also a charting library called interactive data display by some of our collaborators. And I'm now actually going to run some real code and hope, and so what this is doing is streaming values from your server. So very similar to the example I was talking about earlier with the CNTK training. This is taking values and that process is asynchronously streaming over to the browser client. So you can imagine situations where you've got some long running computation and you want to see what's happening. You want to go to field for whether it's converging to the right place. And this is a general piece of technology that people can use in a lot of interesting ways. OK. Now, for those of you who were at Chris's talk earlier, then he mentioned a feature of F-sharp called type providers, which are magic. So what I'm going to do is show you a little bit of these working. So also there's a library called F-sharp data. And what this allows you to do is treat the data as something you feed into the kind of compilation process. And the reason why this might be useful is that you might want to do things like code completion against things that exist in your database without some poor person having to write a huge layer in between. And so what we can do here is we can go to the World Bank, which makes this freely available data. And we can just treat it as XML. So we can put in the URL. And we say, we're working with XML. And it'll pull it all down here. And then we've got this whole mass of stuff. And then somebody's job is to go through this, find out some signal from it. You have to write some code to go back and forth. But they've also provided a type provider. And what this is allowing us to do is to say, just get the context of the World Bank data. And then I want to be able to write F-sharp code in this environment without having to have somebody do some kind of script to generate the F-sharp code or somebody having to write all that code by hand. And so it's a bit like code generation at compilation time. You don't have huge reams of code on the disk that you have to be very careful with. And it's also, in general, updated every so often. Now, I'm not going to, I can't demonstrate this easily because it takes a few seconds. Don't want to rely on the Wi-Fi. It'll all come down crashing. In general, if you're on a reasonable network connection and you're not being watched by lots of people, it's totally fine. But the interesting thing as well is that not only can you do completion at design time, so when you're writing the code, you can have these things that don't really look like methods. So F-sharp has this syntax of double-backed graves to let you put longer sentences in. And so they've made this more readable. Now, they could just mash it down. But this, again, it's for a different audience than people who primarily think of themselves as programmers. And this allows you, and I've done this with some of our own research, pulling down off data storage and pushing it through to an API that people can then work with. And again, it's a little bit like people who were at the gaming scripting talk earlier. It's giving a set of people who are a different set of skills the ability to work with the engines and tools that you're building so that you don't have to provide a lot of the scaffolding. And they have skills that the programmers don't. And so you can work through it and start the chart. Again, with the similar libraries to earlier. So this is just showing changes in the amount of trade that's going on for Belgium. But there's also other things you might want to visualize. It's like, can I get a sense of this from a kind of global perspective? Now, this, again, is a lot of stuff that you go into a data processing environment. People are often surprised. I think there's magic machine learning where people spend all their time. There's actually this whole section of time where people have to reshape and restructure the data, which we've got a whole set of libraries. And because the type provider has pulled in that structure, which is quite detailed, it gives you the ability to pick apart that data with types and safety. So what normally you would do is probably identify names, and then it would run. And if the data gets restructured, or somebody adds a new record in a way that they shouldn't, you'd get runtime blow-ups, which would be unfortunate. This way, you get a lot more confidence that you're working with the structure itself as pushed into your compiler. I won't go over the details of this. Again, the notebooks are all up available if anybody's curious how to do this restructuring. But one of the other map types that plotly makes available is this kind of worldwide map. And again, it's all very interactive. So what this is showing is the change in export over time. So as countries have moved towards doing more exports, now this is the first record from the start of the years, and then there's another map down here, which is later. Now you look at them both, they're both quite beige, there's differences, you could see eye to eye. But again, when you're trying to tell stories or communicate things, you often have something in mind. And so what I've done here is taken the first record and the last record, and let it show the difference between them. And so this is the type of thing that you could write a fairly short amount of code, and if you did it in the context of some business-relevant problem, then you might be able to make this available to people who care about these kind of outputs as well. Okay, and again, all this stuff is like external libraries that we've wrapped up into a .NET context, made available, made a convenient, safe API. I did mention machine learning and passing. There's quite a nice statistic library called Accord. It's relatively straightforward and all runs locally. I'm just gonna show it in quickly passing, because I think it talks to a little bit of the question of interactivity. So imagine the kind of task where you're trying to detect faces in this, and the library has an ability to a pre-trained model. And what we can do here is we can run them, we can run it through, and like the initial configuration, you get all sorts of like faces everywhere. Anybody's familiar with this series? Maybe not surprised there's faces everywhere. But what you can do is then work interactively, adjust the models, and move it to getting closest to the right answer. Now what you really want is a much more powerful library, and there are all sorts of examples. I'm only gonna show this much so far, but there's also some samples here of running with TensorFlow Sharp, so Miguel's library that he's worked on, as well as PyTorch and also ml.net. But those are all in the samples and they're all available. I'm just gonna switch over and then wrap up. And so some people kind of think about this as like one side, like people do one or two little notebooks. There's this interesting observation that some of the folks at Netflix now run tens or hundreds of thousands of notebooks overnight. So they do this process, they have a data analyst, find some interesting signal, and then taking from their huge corpus of data that changes every night, they've built tools so they can run these automatically, and then provide those like freshly baked analysis and visualizations that people can go on and do forever exploration. There's a, I think, yeah. I think I'll call it that. If anybody has any questions, there's a couple of minutes. Yes, quite limited so far. This is an actual topic. There's some issues on the tracker. And if you wanted to get involved, then there's been some preliminary work. Any other questions?