All right, I think that we can start. So this is Miguel. You all know Miguel. Miguel is known for starting a lot of projects in the open source community. He started GNOME, started Monoid, started Moonlight. Right now what he's doing, he's doing a lot of slides with 12 cats in it.

But no, he's still leading the Monoid project, Moonlight project, Monoid project. Either we do an introduction of 30 minutes or just keep it short. All right, thank you, Stefan, thank you, Stefan. And thank you to Ruben and Stefan for setting this Monoid developer room today.

So as an enemy of freedom, I'm here to pollute your thoughts. Thank you, thank you. You know, the other day I passed Richard Stallman

on the street in Cambridge and I said, hey, Richard. And he kept walking and I was like, all right. You're okay, I think he doesn't like me anymore. Anyways, I wanted to start because the last time that I did a presentation at FOSM, some of the most sensible people in the audience were a little bit upset because I showed a commercial product.

So I'm gonna try very hard today to not show you any commercial product, to not offend your sensibilities. That being said, my good friends from that commercial company are here. Lucas Meyer, who does really interesting work and Massimiliano Mantione, who's there, now work for that company that writes evil software.

So they're really good guys if you want to talk to some people who are bringing really interesting stuff. Anyways, I'll try to keep the Coca-Cola out of the discussion, but it might not happen. So if you're a person that is easily offended, you might want to leave now. Okay, that being said, damn it, what is going on here?

All right, here we go. So I'm gonna give you a quick update of where we are with Mono today. As it turns out, I'm not gonna cover some of this stuff. Julius covered Mono develop this morning and the amazing things that we're doing with debugging there. I don't think that his demos were as good as all of the things that it does today,

but that's okay. You know, as you know, we've been working on Mono for a very long time. It's almost been 10 years since we started. We're in the ninth year of working on Mono, and a lot of things have happened there. When we started the project, I thought, as usual, I thought that we could be done in about two years,

and somehow I'm still doing this. So, you know, it's been a very interesting, it's been a fantastic experience, of course, and I don't regret any minute of it. We started working on Moonlight about two years ago. No, what, three years ago? This is the first time that we actually got Microsoft to collaborate with us, and it's been a very interesting experience for us.

Mono develop was a project that was, a project that started actually out of the community. It's something we were never planning on doing, and it's odd, and I'll explain to you why in a second when I get some of the other topics.

So those are the three major projects that we'll work on. And then finally, we kind of do commercial projects, so I'm not gonna even discuss those things today to not offend some of you. So I'm just gonna focus on the three, one above. So a quick update, since the last time we were at FOSDEM, we've done a lot of things,

and we've released a lot of software. We've been releasing software like crazy ever since. We did our Mono 2.0 release. This was a getting feature parity with .NET 2.0. We did our 2.2 release, which was mostly about improving the performance and upgrading our JIT engine. Our JIT engine needed some very significant upgrades.

We did that work with 2.2. And of course, in each one of these releases, we keep improving the KALAS library support and things like that. 2.4 became the first long-term supported version of Mono. So this is the first time that we said, we're gonna support this with bug fixes, security issues, and so on for 18 months.

So it's been more work than we actually wanted to do, but it had to be done. So that's Mono 2.4. And that's a release that we officially support and the release that we officially fixed bugs for. And finally, the release that we just released, we just released 2.6. It brings Mono to .NET 3.5 compatibility,

just a few months short of Microsoft shipping .NET 4.0. And we'll talk about what our plans are there. Now, with Moonlight, again, Moonlight started as a project, it was kind of a stunt. And you have to remember, if you put it into context, Microsoft really never liked Mono.

They were never very happy about the existence of Mono in the first place. So for example, we went to their conferences and we tried to get talks approved at their conference, and they would always find a way for either rigging the votes or making sure that, oh, all the rooms are full. Oh, sorry about that, you can't really present. Or, oh, we lost the paperwork, you don't really have,

you can't really present here. So we used a number of guerrilla techniques over the years. The first one was that we used Post-it notes and we actually went and patched the programs. So we announced the alternative BOF session of Mono. That was the first thing that we did. The second thing that we did was we,

you know, some rogue Microsoft employees actually got us time inside their talks. But it was kind of unofficial. So that was on that same year, PDC. The other thing that we did is then we hosted a launch session. So in the middle of the hallways for the Microsoft conference, there was a launch area and we had a meeting there.

And there were about probably 80 people there. And we had to yell, basically, to get the message across and gave t-shirts. So that was a really good year. The third year, we couldn't really have, we couldn't really do that because the police, the last time, actually were not happy about us using space that we hadn't paid for.

So we actually rented a room about a dozen blocks away from the conference center and we had people come in. And that was a lot of fun because a lot of the Microsoft employees actually showed up and a couple of people in the community actually said, this was really good, it was scheduled to last for an hour and last about five hours. And it was just a bunch of happy open source people

exchanging ideas with each other. Then things started to change slowly. With Moonlight, we kind of, so just so you know, what we're trying to do at that point was, we're trying to promote the idea of an open source implementation or running .NET applications on Linux.

And so as I said, this didn't really go well with Microsoft. So one day at one of these rogue events, it turns out that we met the guy from Microsoft France, Marc Jalavert. And Marc says, you know, I would really like if you guys come to the mix conference and do a talk about Moonlight. Or no, it didn't even exist.

I'll talk about Mono. This was just after Microsoft had announced the Silverlight and I said, I actually like this very much, we're going to build an implementation. So this is, you know, in the heat of the moment, a journalist comes and asks me, so what do you think of this? I said, this is awesome, we're going to build a clone. I didn't really think about this, I didn't talk to my manager about this,

I had no budget, I had no permission, but I figured out what can happen. Right, because like a friend of mine in Mexico used to say, my friend used to say, you know, when it comes, you know, when it's a time for fast decisions, I'm a man of action, right? Have you heard this before? I've repeated it like a million times.

You know, when there's a time for, you know, for acting quickly, I am a man of action. And when the time comes for calm, rational decisions, I'm a man of action. So, I am a man of action, so I, you know, I announce that we're going to do that regardless of, you know, without any permission. And what was interesting is that this guy,

Margiela Bear, said, hey, why don't you come and present Mono at the Microsoft conference in Paris? And I figured, well, I need to take this opportunity because this guy, he hasn't talked to his boss, because if he does, they're going to shut it down. So, so I said, yes, of course, as long as you don't announce it. So, he didn't announce it, and I didn't think

that he was serious until one day when he sends me an email, I say, hey, we were serious. We want to have you in the keynote. And, you know, if you want, we'll give you a session too. So, so I said, and why don't you talk about Silverlight on Linux? And of course, we had absolutely nothing. We had zero lines of code written, nothing done.

So he said, yeah, of course, we'll show Silverlight on Linux running, no problem. So I sent an email, so I sent an email to my team, and I said, okay, guys, we got three weeks. Whoever wants to join on this hackathon, we need to make Silverlight run on Linux. So, who's in? And, you know, about six or seven people said I'm in.

And I don't think we've ever worked as hard, you know, I've never worked as hard in my life as those three weeks. It was 21 days, and I think that we're working, you know, 18 hours, 20 hour days for three weeks. But we managed to get, we managed to get all of the demos that Microsoft showed at the previous conference at Mix in March, ready by the, what is this thing,

June 21st, that day where the French make that, they have this celebration and the street viewed musicians. Anyways, it was that day. And just before my presentation, now, the problem is that the night before, the Microsoft guy calls me and he had to notify his boss that he was having me on the keynote.

And that didn't go very well. But anyways, the guy kind of said, okay, we already made an announcement, we're gonna let it through. So what happened is, we did the announcement, we showed this stuff, and I was updating from SVN five minutes before the demo, just to get the last fixes in.

And we actually, we managed to demo it. It was very broken, of course it didn't have a security system, it was lacking a lot of things, but it was able to show at least everything that Microsoft showed at the previous conference. So it was quite an achievement. Then we signed an agreement with Microsoft in which they agreed to give us test suites

to make sure that Moonlight on Linux was, ran everything that it was supposed to run, and they gave us access to their engineers so we could ask them questions. Now part of the agreement is, we really didn't care about Moonlight 1.0, which is JavaScript on the engine, we only cared about this one. But part of the agreement required that we build the 1.0 runtime. So we said, all right, let's go build that piece of junk.

So we built that thing, and there were probably only one application which was the live streaming of Obama from, the official field was running on Silverlight. So that was probably the only use that we had for that. Then we released 2.0, we just released 2.0 a couple of months ago. The reason why it took so long from, you know,

we had most of these done in three weeks, why did it take us two years to build it, is because we needed to have a security system in place. Monod didn't have a security system, and basically trusted everything you did. So if you said I want to access the file system, it would let you access the file system. I want to scan the file system of the user,

copy each file over a network socket and post it to the internet, it would let you do that. So obviously, you know, obviously this didn't really work. Because when you're on the internet, you should assume that all of the code that you're getting is hostile code, right? So it took us a couple of years to work on this. We had to build a verifier, we had to build a security sandbox,

we had to audit the code, we had to, you know, add security policies to sockets, we had to add whitelists and blacklists for APIs to make sure that the entire system was locked down. And Microsoft did help us, and Microsoft actually did help us make that happen. Now, as of, hola.

As of last week, we released our first version of 3.0, so we're catching up quickly to what Microsoft has, and this is our first preview of Moonlight, and we're hoping to do another release in the next few days for the Olympics. The Olympics, at least in the United States

and a couple of other countries, will be streamed live with Silverlight, because Microsoft has done the business development on that area. So we'll be streaming that using Moonlight. There's still a couple of bugs here and there, and we don't support Chrome, and it's all, Andrea's fault, who is right there. So if you're a Chrome user, she's the person that you need to complain to for not fixing that bug fast enough,

despite the extensive two-week period that she had to fix it. So, anyways, Andrea, raise your hand if you don't know us. So she's wearing black, so if you're a Chrome user, like everybody else, and I stopped using Firefox a couple of weeks ago.

Anyways, we have a couple of nice things in store. I'll talk a little bit more about this, but Mono 2.8, which should come out a few weeks after .NET 4.0 ships, is gonna be a big release for us. It's gonna be big in a couple of ways. The first one is that,

is the first time that we're actually gonna ship the C-sharp language compiler at the same time as Microsoft is. So, in the past, for example, when they released C-sharp one, it took us about a year to get C-sharp one. When they shipped C-sharp two, it took us about a year and a half to get it. C-sharp two was a very complicated process for us.

C-sharp three, again, took us about a year late. With C-sharp four is the first time that we're gonna have, in fact, the compiler is ready to go out now. You can get it today, it's complete, it's finished, it's done. And this is before their compiler ships. So, they're both in beta, and by the time they're shipped, they're both gonna be in release mode. So, you should be able to get that.

The other piece that we did is, with 2.8, we're switching to LLVM as our code generation engine. Well, we're not switching. We're making it an option. And what that means is, you'll be able to continue using Monos fast JIT engine for most operations, but for certain loads, you'll be able to use LLVM. And 3.0, which should be out in June,

is the first time that we're gonna have a compacting garbage collector. I know that most of you people don't care about this. In fact, Lucas last night was telling me, don't talk about LLVM, don't talk about SGN, nobody cares. 30% performance increase, nobody cares. I'm like, all right. So, I'm gonna keep it short.

Then, monodevel, we did 2.0 and 2.2. So, it's been a lot of focus since the last time I was here at Fosdom, and it's been a lot of fun. Now, of course, I don't really have the time to talk about everything that is going on in the mono world. It's too complicated. This light is just up, so you can read it quickly, and we can move on quickly.

But there's too many things happening. And when I had to pick what to talk about today, I really struggled about what is it that I wanted to talk to you today. And to some extent, it was a choice that was made simpler because UIs was talking about monodevelop, so I didn't have to do that. Ivan was talking about Aaron Ruby. I don't need to do that.

Alan is having a talk about, Alan has a talk about btorrent. I don't need to talk about that. So, there's other talks that will complement what I should have said initially. But there's a lot of real interesting things happening. Like, for example, our C-sharp compiler, which is written in C-sharp,

actually there's about 12 different forks of the compiler. So, people have taken our compiler and made changes, and they're exploring different language techniques or things like that. So, it's been a very interesting experiment. And I won't even bother going through the rest. And do we have any water? No, we don't. All right, well, I already talked to you about this.

This is our Microsoft collaboration for Moonlight. And although it was initially a collaboration around Moonlight, it seems like they are willing to extend this collaboration now to Mono on the server, which is something that I thought they would never do. Now, a little bit of a patent update, because I know that all of you

are scared shitless about patents. So, the most important thing is that, compared to pretty much any other piece of open source software, actually Mono has gotten the most patent covenants, and that is the most patent coverage than anyone else. And in large part, because there's been an uproar

in the community about, well, what is the situation with Mono and patents? So, this is a quick update on what we have today. C Sharp is covered by the Community Promise, both the ECMA 334 and the ISO versions of the standard, which means you can use it for anything you want. The patents are only available for C Sharp implementations,

which is actually quite ironic. It basically means that you're more protected from a Microsoft patent thread if you use C Sharp than if you use another language that copy ideas from C Sharp, because the patents are not granted to those. I think that there's something to be said of Microsoft not having the interest of the open source community

at heart, so that is true. But as I said, at least the C Sharp piece is available. The same thing applies to the CLI, and the ECMA Committee is in session for publishing the sixth edition, I believe, of ECMA 335. Other pieces, things like ServerLite are covered by XAML, by ServerLite XAML, as well. So both vocabularies for ServerLite are in the open,

and those ones come with no strings attached. So that is pretty good. I forgot to mention also that the Moonlight 3 and 4 Covenant no longer has a Novell-specific coverage. Everybody's covered equally under Moonlight 3 and 4,

unlike the previous version that was Novell-specific. This time Novell gets the same rights as everybody else. There is one difference, though. Novell is a license source to MPEGLA, which means that when you get the software from Novell, you will get codecs. So H.264 and VC1.

Just like with Google, you have Google Chrome and Google Chromium, and Google Chrome comes with codecs, and Chromium doesn't. The same thing applies with Moonlight. If you wanna get the codecs, you need to talk to MPEGLA and figure out what the licensing seal is there. This is not a Microsoft patent, this is an MPEGLA patent. Then additionally, there's a bunch of grants,

of patent grants, that come with different pieces that Microsoft has open-sourced. So they have open-sourced ASP.NET MVC, the Dynamic Language Runtime. We just heard about that a few minutes ago. Orchurch, which is a content management site, ASP.NET Ajax, a managed container framework, and two languages, Iron Python and Iron Ruby. And there's a couple more things to come,

but we're not ready, well, they're not ready to announce that yet. The rumor is that F-sharp will be an open-source compiler, which is an interesting language for a researcher. It's a rumor, and that's all there is to it. So, now when it comes to, so that's kind of an overview, a quick overview, and we're probably gonna touch on different subjects

from now on. And the problem is that, a couple of months ago, I asked, so what do people wanna hear about, I was doing a presentation on Stack Overflow, and I said, what do you guys wanna hear about, about Mono? And so I made a quick poll, because these days, my entire life is driven by what people say on polls.

So I set up a Google poll, and I asked people what to do. And the problem was that, as you can see, there's really nothing out there that, you know, it seems like people don't really have a good opinion, there's no one topic that people really wanna hear about. So I ended up figuring out that, I'll just talk about whatever the fuck I want. And it might be interesting, or it might not be.

Now the bad news is that already, you just took Mono develop, so I can't talk about that. And I can't talk about any Coca Cola based products. So, you know, so technically, you know, I shouldn't say that 500 applications on the App Store are built with Mono, and that 10% of the top selling games

for the App Store are built with Unity's product. So I won't mention that. But I will talk about happiness. Right, so I read this book.

You know, there's a couple of journalists that are obsessed with everything that I do in my life. And, you know, I do like the attention. I do like the attention. But you know, the problem is that they really don't like me. So you know, that can be kind of a bummer. So I read this book a few years ago.

I read it again every time I read one of these clowns writing in the press. And you know, I strongly recommend everybody to read it because it's a really nice book. Well, I'm not gonna tell you. Because that is my secret sauce. That's what keeps me happy. Now, the name of the guy, the guy is called Benjamin Zander.

And he wrote a book called The Art of Possibility. And you know, I met this guy once. There was a dinner of a bunch of interesting people. And at the end of the dinner, they said,

well, you need to go. There's a presentation specially for you guys by this guy. And he's the director of the Boston Philharmonic. And we all got together, went to this thing. Kind of wanted to go home. You know, just go to the hotel and call it a night. But we went to see this guy. And this guy is the director of the Boston Philharmonic.

And he just exudes joy, right? So basically, the guy just had a flight cancellation. He couldn't make his flight. He lost the train. He lost everything. But you know, he still managed to go there and teach us about what made him tick. And you know, it was a very encouraging talk.

But at the end of the day, you know, there's a couple of things. There are things that make you happy and things that make you happy. And you know, you might as well just focus on the things that make you happy. So I'll tell you a little bit about what makes me happy as a programmer. There are many things that make me happy. But as a programmer, you know,

Ivan was just talking a few minutes ago about Ruby. And I was telling Jim, dude, he just stole my talk. But is Ivan still in the room? You might know his question. Right, so, you know. All right, we'll get to that in a second.

So anyways, as a programmer, you know, every time you guys take a shower, well, at least that happens with me. Every time in the morning, I don't know why it happens, but every time in the morning, I get into the shower and I have like a billion ideas of things I want to do, right? And the moment I step out of the shower, it's like, eh, fuck, I'm not gonna do anything. You know, you go, you check your email,

and you know, and by the end of the day, your life is gone, you've read all this junk, and you didn't do any of the things, great ideas that you had during the shower. It also happens when I'm walking. When I'm walking to work, I have billions of ideas. And so I decided to get a tape recorder, and these days what I do is I record my ideas and hoping that one day I'll have time

to make them happen. And what happens is that many of you, when you have an idea, you know, the question is how you bring your idea to the world, right? And this is basic software engineering. So I'm just talking about ideas in the software engineering realm.

You know, sometimes we get, we're too full of ourselves, right, we fight about self-determined freedoms, and we fight about what's good for the world, and in the meantime, you know, the Palestinians are being massacred, you know, the Haiti's destroyed. So you know, putting things into perspective, you know, it's a small world. But anyways, so just from the engineering perspective,

right, you have your idea, you go and write your program, and it's a good program. You're happy with your program. Now the question is how do you bring these to the world? Right, and usually people get confused. We have an eraser, yeah we do. So you know, sometimes people get confused because,

you know, I don't know if you guys have heard this discussion and they say, well Linux doesn't innovate, or you know, Windows doesn't innovate, or you know, Apple just copied this from someone else. And I actually went and looked up the definition of the word innovation. And what is interesting about the word innovation is innovation doesn't mean having an idea, because every one of us, when we're getting,

taking a shower in the morning, have, you know, we have a dozen ideas, and every time you go to work, or you know, whatever else, you have hundreds and hundreds of ideas. So it's not that the world is lacking in ideas. It's not like we don't have those ideas every day. But there's a very big difference between having the idea and coming up with a new idea,

and making it happen, but not only make it happen, but make sure that you can actually reach the public. So it doesn't matter if Microsoft had a tablet 10 years ago, it doesn't matter, nobody used it, right? Chances are that Apple will be successful there. It doesn't matter that Microsoft was first with the mobile phones, and the iPhone won, right?

So innovation is a combination of actually having that idea and bringing that idea to the market, right? So my, what is my heart is doing? This is doing something, anyways. So just from a purely geek perspective, what we wanted to do with Mono many years ago,

our whole point was, how do we make programmers more productive, how can we help programmers go from the idea to the market? I don't know that we have an answer, but I'll tell you what, you know, I'll tell you what the basics are, and maybe how we can help you get there. So once you have a program, this is basic software engineering, like I said, you can decide to turn it into a programming product.

And a programming product is basically taking your program, making sure that it's documented, and making sure that the bugs are fixed. That's it, right? And typically in software engineering books, you'll read that it actually takes three times as much work as building the program, right?

So, in fact, I tell my team sometimes, every time they go and implement a new feature in Mono, they go and add a feature, but they never document it. They never document it, they never put it on a webpage, and I'm looking at you, Masi. And the problem with this is that if you write code and you don't document it,

you might as well have never written the code, because there's only gonna be a couple of people that will ever find this feature, right? So it's very important, I know that we all hate writing documentation, but if you don't write the documentation, if it's not Googleable, if it cannot be found, you might as well not have written the code, because nobody's gonna find it, it's just gonna be wasting space and wasting our time.

So it is really, really important for everybody to write documentation. I know it's annoying, but I've actually developed a habit of writing docs for stuff. Now the problem, as I said, it might take you a day to write the program, it will take you another two days just to fix the bugs and write the docs. Now, you might decide that you're an elite hacksaw, right?

And that, you know, documentation is for woos. And, you know, for example, this other one also includes releasing your product, making it horrible, making an official release, right? For example, I love the FMVMPEG people, because they write awesome code, but for about five years they said, we're never gonna release it horrible, right? They were not building a product.

A programming system, on the other hand, is the idea of taking your program and actually interoperating with the rest of the system. That means using standard system configuration files, using existing APIs, right? So, for example, instead of just talking to dev audio, you have to talk to whatever audio API we have this week on Linux, right?

So that's what the programming system is. And that also takes three more times than writing a regular program. Now, of course, the nice thing is actually going to what is called a programming system product, which is basically the combination of those two. The problem is that it basically takes you

roughly an order of magnitude more time than building your program. So if you have a quick hack that you built in a week and you wanna turn it into a programming system product, you're looking at two and a half months of work, right? So you have a cool hack that you built in a week, really it's gonna take you two and a half months. Which kind of explains why it's taking us so long for Mono to go from the idea that,

oh yeah, we can implement .NET in a month, and the fact that it's taking us 10 years. So, anyways, let me take a little detour here. So when it comes to the, so again, when it comes to enjoying the stuff that you're writing, right, you know, there's certain people

that certainly have a pleasure with assembly code. You know, there's some of those. For example, there's this guy, Mac Acton, that writes games, and the guy just writes assembly code for the SPUs on the PlayStation 3. And the guy is really good. But you know, there's only a few people that enjoy that.

And the other day we were having an argument because he said, when you write software, you should only care about performance, you should only care about bandwidth, and you should care about how many bits per second you can move to the screen. Right, that's a very game-centric view of the world. And, you know, and I was reminded that Ruby on Rails pretty much revolutionized the entire web development industry

by making it fun to write web apps. Before Rails, there was really the before Rails where everything was a pain in the ass, and nobody really enjoyed building web apps. It was really, you know, it was cumbersome, it was unnecessary, there was no joy in that. And Ruby on Rails kind of changed all of that. It made it so innovation was enabled

because it was easier and was fun to build applications. So, in my personal opinion, I think that anyone below the C-sharp barrier is just miserable in their life. You know, one or two might disagree.

So, yeah, I'll get to that. So, why do we like C-sharp? And I kind of wanted Ivan to be here so we could have a good fight, but he's not. It's a high-level language, it has a C-sharp-y, you know, it has a C feel to it, so we like that. It's also, it's an interesting language because the first time that I used C,

let me take a step back. Many years ago, I built a spreadsheet called Gnomeric. And Gnomeric had an implementation, we were just having that discussion yesterday, and Gnomeric had an implementation of sparse arrays, right? Because the problem with Gnomeric is that, you know, you have 65,000 columns, or I can't remember, 256 columns and 65,000 rows,

and usually you don't have all of that allocated. So you can't just use an array. You actually need to use linked list and a representation that allows you to walk this without allocating all that memory. If you only have one cell in the middle of the spreadsheet, you don't want to allocate, you know, 128 columns and 32,000 rows. You just want to allocate that cell.

Right? And I made so many mistakes in that implementation, it was not even funny how many mistakes I made on that. You could argue that I was an incompetent coder, there's certain truth to that. But also, I finally got my hands on a tool, at the time it was called Insure, and now we have a tool called Valgrind that does something similar.

But basically, you know, I spent hours with Insure trying to find out why my application was crashing. And it turned out that, you know, a lot of those errors could have been found if the compiler had warned me ahead of time. Which is when I started using all of the possible warnings possible in the compiler, because I figured it's cheaper to put the warnings in than run with Insure.

Right? Not everybody had access to Insure back then. And that's kind of why we started adding warning all to Gnome. Because we wanted to make sure that we had as few errors as possible. But C-Sharp in particular is very good at that because C-Sharp went beyond the sets of errors that were reported by C or C++ compiler.

They actually flagged a lot of other conditions as errors. So for example, you're never allowed to use a variable if it's not initialized. So the compiler will make sure that if you're trying to use a variable that is not initialized it will just not compile it. You can throw it at it, but the compiler will just refuse to give you the output. It won't compile. You use a variable that isn't initialized,

you're not going to get an executable. With Moonlight, you know, after many years of writing C-Sharp code I was very happy, and when we did Moonlight we chose C++. And every once in a while somebody will add a new field to a struct and they will forget to initialize it. And how many of you write C++ and have found that problem?

You know, and every time that happens we spend a week, well not a week but a day. Somebody did this and now something is crashing elsewhere and you spend a day trying to find out why that happened. Right? So there's a couple of, you know, you can do things like creating your allocators and, you know,

there's tricks that you can use to do this. But this class of errors just never exists with C-Sharp. You know, the compiler just tells you right from the start you can't do this. And there's really no I mean, you can't really talk the compiler into doing it short of, you know, patching the compiler. And even then the VM won't let you allocate objects that are

uninitialized. So that's one of the things I like about C-Sharp. C-Sharp is very good at catching mistakes way before you make the mistakes. So that's good. The second piece is it does automatic memory management. You know, I'm already 37 years old and, you know, statistically I've lived half my life and I don't want to

spend the rest of my life, you know, tracking another memory corruption bug or, you know, spending more time releasing memory that, you know, that's what computers are for. Some of you that are 17, you guys go and choke on as much C as you want. I'm going to be But I've moved on. I've moved on. I want the computer to take care of that for me. So that's

why I have developers like Alan McGovern raise your hand. He's still very young and that's why he still has to write C++ code. But some of us have moved on to other things. We just don't have that much time left. It is also interesting because the entire class library was designed with multithreading in mind. So this is not something that was

added at the end. They didn't add multithreading as a, oh, fuck, now we have threads. What do we do? Which is pretty much the reaction of every API that was built for C and C++ historically. It's always an afterthought. With .net multithreading was in there from the beginning. So every single class has a very strict

contract in terms of what the guarantees for multithreading there are and the rules that you can follow to know how something gets multithreaded. So by default, every static method is multithread safe. Every instant method is not. So if you create instances, the instance is attached to a thread. If you need to share it, you need to lock.

So very simple rules for that. And when it comes to language as, you know, Ivan and I will disagree, but when it comes to the language, it kind of has a good mix between being overly verbose and being good enough for writing code on a day-to-day basis. So, you know, it's a good language.

And the other thing, finally, is that C Sharp is already in its fourth revision as a language. It's been upgraded at least three times from the initial release, and there have been very major upgrades to the language. So, as you know, C Sharp 1.0 was very similar to Java, and every time you hear somebody say, well, C Sharp is just a copy of Java,

they referred to the state of the art in 2000, and they obviously have not used C Sharp ever since. It had a couple of extras. I'm not going to go into those. In fact, this morning, I was adding one slide per feature, and, you know, I was up to slide number 20. I figured, I don't think anybody really cares. So, I deleted all the slides.

But, you know, it had a couple of interesting ideas. Delegates, which are object pointers, you know, they're pointers to functions, but they can be pointers to functions in an instance, in an instance of a class. So that is very interesting. The rest of them we're not really going to talk about. But one of the interesting features is that

it had very strong interpretive features. So C Sharp was designed to play nice with others. Then C Sharp 2 came out a couple of years later. It's very interesting in that they added generics, similar to C++ templates, but they didn't only add generics to the language, they added generics to the VM. And what this means is that you can actually

do generics across multiple languages. It also means that you can specialize code at runtime. It also means that you don't lose type information when you compile the code. A couple of, Microsoft had a couple of interesting researchers working on the language, so they added icon iterators to the language. This is the foundation

for many things, but in particular games use this technique. Lucas can tell you everything about iterators and how they're used in games. Michael Hutchinson has a brilliant post from about three days ago, or five days ago, that explains how these engines work

using iterators. Because games have very particular programming techniques when you're building the AI. So if you have 10,000 guys on the screen, each one has a little piece of AI, how each one is independent. So the idea is how do you execute a little bit and then suspend execution without having to use a thread per object. Let's say you have 5,000

characters on the screen, you don't want to have 5,000 threads. So it's kind of a lightweight threading system that you build on top of iterators. Really interesting post if you want to see that. It's Hutchinson's blog. Anonymous methods, this was the beginning. This was the beginning of turning C-Sharp into a functional language. It didn't look like that at the time, but it was

starting to be there. And it added some of it was likely to be scoped, so it started to get some of the functions of Scheme. I was going to say something about anonymous methods, I forgot. Fuck. Alright.

Come back to me. C-Sharp 3 came out a couple of years later. And the big focus of the release, the big, big focus was this, let me show you that, was this extension of the language that allowed you to query objects. what am I doing?

Maybe I should just do this. So this is our interactive C-Sharp interpreter, it's a REPL. And in fact, let me do using system, I think that's already there.

Well, that's a bug. Ignore that. Actually, that's running the development version. Let me run the other one. This is the non-development version. So that one works.

Right, so this gives you an idea of how this thing works. And what works with Link is basically you can say from x in directory.getFiles and et cetera right, where x ends with .conf select x Right, so this is the query language.

And the way that this is operating, we'll go through this step by step, but what happens here is that directory.getFiles returns an array. And the language has been extended so that it understands how to deal with arrays and you can query arrays. So what happens here is that the return value of this thing gets assigned to x. Right, and this is where

you evaluate this thing. So you say where x ends with, so this is your conditional expression, select x. What's happening here is that really C Sharp is rewriting your code. That in reality is something like directory.getFiles and I'm going to write the rest. And then you say .where So it's actually calling the

where method on that. And it's an extension method of late to arrays. And what the where method is taking is it takes a parameter, x, right and it's using a lambda function and it says, well, if x ends with this and the return of this thing is a boolean,

right, then it invokes the method .select. Right, and the return of this beast is actually the return of this beast is actually an IEnumerable. What is interesting about this piece is that the reality is that when

I run this thing when I, well let me see this, var y equals from x in directory.getFiles etc. I'm only going to do the where, select x.

If you get the type of this beast it turns out well, let me just scroll it up so you can see it on the back. So when I run this expression you'll see that the value of y, right, because C Sharp infers the types right, so the actual value of y is system link enumerable createSelector iterator, iterator 10. So what happens is

that it actually hasn't even fetched the files from the directory. What this thing has done is it has constructed the actual expression that is ready to run. It builds a pipeline, right. So the entire link system is built on the idea that you create pipelines, right. So the first one is the get directories the getFiles call

and then the output gets connected to the where method. And these are all enumerable, so things that produce data when you call them. So these will produce a list of files that will get connected to where and these will get connected to the select statement. And eventually these will produce a value, right. So when you iterate

over these values you'll get the values back. I don't know if you noticed this but you actually, when you're kicking the pipeline I'm not sure how familiar you guys are with enumerators, but an enumerator basically iterates over a collection so what you say is, okay initiate the enumeration and then you keep looping and you say, do you have more values

and if you do, get me the next value. So it says, do you have another value? Yes, yes and it fetches one value one after another. So every time that you do this, what happens is that, you know, you call the pipeline and the pipeline basically says, well, do you have another value, so get files fetches the next value.

It sends it to where and where determines yes or none, if not it goes to the next value. So what happens is that every time that you run this, you run the pipeline. So you run a pipeline every single time. So in this case here, the directory has not been fetched. It hasn't even done the directory listing at that point. The way that you do that is if you

do something like, if you force the iterator like for example, var a in y, console dot write line a. So that's when it actually iterated. So what I did there is basically at that point, it did the directory files call and then it runs a where statement

and it runs a select statement and this is a foundation for delayed execution. So everything that you're doing with link today basically delays the execution until the very last minute. this is not an interesting side effect and I'm not going to go into that

but if you guys are interested Microsoft just released a new framework called the reactive framework and it's based on the notion that you know, the guy that invented this is actually is actually a functional guy and they realized

that iEnumerable is actually a mirror of iObservable. So they realized that just like their operations for enumerating a collection, you can actually turn it around and instead of enumerating and basically requesting the next token you can build the exact same pipeline on the other way and

instead get notified when events happen. So you can say, well when something happens, let me know and here's how you let me know. Anyways, it's worth researching that if you're interested in the subject. Now so this was the beginning of turning C Sharp into functional language. There is a fascinating

look at C Sharp as a functional language, as a purely functional language in one of the Microsoft blogs. I strongly recommend you read it because it's an easier soft landing into functional languages than functional languages themselves. Anyways,

one of the things that they did with link like I said is what I just showed you is link to objects. I would show you the XML one but I don't remember the syntax and I'm not going to embarrass myself by trying to do it live. So just go do it in the comfort of your own home and the privacy of your home. The other one that they

did is link to SQL. And what is really interesting about this is that is how they did this and I'll explain that in a second. But in general the link infrastructure is not bound, it's not limited to these three Bs, the blue ones that Microsoft shipped, but you can build link to anything that you want. Right? So today there's like

50 link providers. Links to databases, links to directory services, links to in hibernate, all kinds of other junk. Now what is really interesting about what they did with link is that and with SQL is the way that you typically you know, you talk to SQL is with object

relationship mappers. Now let me tell you a story before. A friend of mine was working at AT&T a few years ago. And they were oh yes, and it was the day that they were in the United States they would let you switch from one carrier to another.

Right? So it was the day that they would let you if you were a Verizon customer you could switch to AT&T or if you're AT&T you could switch to T-Mobile, you could switch from any company. It was the first time that you could do this and not lose your number. It was a law, it was passed and every telco was supposed to do this. So they built some software for doing this thing. But the problem is that the software that they built used an object relationship

mapper. That means that you write very cute object oriented code. So you have classes and those classes map to a database. And the problem is that when you do this, all of these object relationship mappers what they do is that they turn a couple of accesses to a class into select statements, a bunch of select statements and very quickly

that translates into hundreds and hundreds of queries to the database. So the day starts and within two hours of the number portability kicking in, the entire AT&T systems go down. And they stay down in the United States for about three weeks. And the problem was and the problem that they had was that they

were using ORM mappers. And it worked fine when you had three guys testing the software but it didn't work when they opened the floodgates to the world. And what happened and the story that I'm telling you is my friend of mine that is basically a SQL admin expert that all he does is go and fix broken databases

when they break. And so what he did is they went to the site and said well what's going on? And it turns out for refreshing a page just with the customer data, they were doing about 2,000 SQL queries. Right? So every page is very pretty, very object oriented but you were doing 2,000 SQL queries. So his job was basically

in a period of three weeks, assemble a team of people that would remove all of the ORM code and just take basic SQL you know, queries in the database so they could get away. During these three weeks if you went to the United States and tried to get your number changed you know, a guy would have to take down your notes in a paper. So if you went to the store somebody would take your

data down in a piece of paper and they would call you in a couple of weeks and they would have to figure out how to reimburse you for the, you know, for the plan charges or whatever. It was a little bit sad. And this was about four years ago. So it's not that long ago. So what they did with link to SQL is instead of trying to come up with an object relationship, you know

ORM system what they did that is very interesting is the same syntax that I just showed you before you know from x in foo let's say you say where x.h bigger than

30 and you know something else, select x, right? So instead of so the way that you would do this typically is you know, if you do this thing with a traditional relationship database manager you would basically go to the database and say well give me all of your records download all of the records to the client

that's a simple way of doing it and then, you know, let me do client side sorting so the client will do the where and extract the data and hand it over to the other side. So obviously that doesn't work and that's a horrible idea of how to do SQL databases. So what they did is remember when I said that actually what this

did, you know, was a concatenation of expressions, right? So basically this would be something like let's say that foo inline database so it becomes foo.where and it contains this expression x.h bigger than 30 and you know the rest of your expression .select, right?

So what happens is that the where method right, typically takes typically takes a function, right? It takes a function that in this particular case it's generic so it takes the x and it returns a boolean right?

Now with C sharp 3 you have a trick. So instead of your where clause taking right? Instead of taking that argument right? That would be a function that you can call and you know you would pass you would pass your x and it would return true or false I would say yes or no which is what it would do. There's

a little trick here which is there's a special type called expression so now your where looks like this and when the compiler sees that you're using the expression type, right?

When it sees that you're using the expression type it does not generate it does not generate the code for this thing right? It doesn't generate at lambda in this case it's generating a method with this body instead what the compiler does is that for this same code it would generate let's remove this so it's simpler

but it would be basically it would generate a tree that has a node it would say something like new bigger than so it's a node bigger than and then it says well it's a field reference in the object x and the field is called

age and the constant 30 right? So basically what's happening is that the compiler is providing you with a constructed tree of the expression as it was found in the source code so it's something like let me rewrite that so basically a node like this that says less than

you know x dot age so you get that node and then you get another node that has the number 30 so what happens is that link to SQL actually gets a tree it gets a full tree expression of what your query is right? And what it does is it transforms this beast

into the equivalent SQL code right? So when you write this piece of C sharp code it actually gets translated at runtime into the proper SQL statement and that's a SQL statement that is sent to the database this can be abused in many wonderful ways and I encourage you to explore this further. So anyways, I'm going to move on

from link there's a lot of papers that you can read on the subject now let me show you for example let me go back to my dingus well this is just the HTTP window I want to show you that there's not going to be any time so again, this is the same expression this is the same expression that I was showing you before

so in this particular case what I'm doing is I'm creating an expression I'm creating this lambda called increment and increment takes a value and then returns the value incremented right? So you could do something like this. So this is a version the non-expression version of it so I can say func func of int and int

increment it's oh dammit I don't know how to do that very good idea that is a very good idea

I like you you're a man of solutions alright, so func int int incrementer, I'm going to call it inc, and this is a function that takes an argument and returns the argument plus one, right? So if I say inc, it tells me that's a delegate, it's telling me it's a function

and contains a bist, so if I call inc with 10 it will return 11 now, the other thing that I can do now is I can say, well, no no no no that is that just did it live, so what I want instead I'm going to call it inc2 is that when I get the expression tree

right? and again, it's the same thing, what? oh, using system link expressions alright, so expression and I really need to add an up arrow to this thing

now, this is the way of open source oh, and it fucking works here, dammit yeah, I wrote this tool, I suck anyways, now let me show you what inc2 is, though

you see this? do you appreciate the beauty are you witnessing the beauty here? I mean, are you getting it? does anybody not appreciate the beauty of this thing? what? no, seriously do you see what happened here?

in this case, inc was just returning me well, I have a function that has this type right, it's telling me it's a func that takes an integer and returns an integer, that is it it's already compiled, there's nothing I can do that's it but in this particular case, it's returning me it's a tree, and the tree the toString method is actually decompiling that thing

and showing me that in human terms let me show you the type of this bad boy so inc getType, again let's look at the first one so that's a precompiled type, now let me show you inc2 getType what is that? it's a system like the expression expression that takes a func inside now, I can't really do much with this thing you know, I cannot use this guy because

this is actually an expression I can't invoke this one like I did the other one so let's go back to the other one but what I can do, there's a service that lets me compile expressions on the fly so now I can say inc2.compile oh my god, this is so exciting alright, let's do this

var compiled so what is compiled? it's that guy and now I can say compiled 10 so exciting so exciting now, this just did an addition, it just added a number it's not that exciting but you can build entire applications with this beast

oh, so exciting what is it nicer? no, no, no, why is it nicer? well, it is not nicer if you don't need it, don't use it right, that's the most important thing in computer science never use something you don't need

now, it might seem very obvious and very stupid, but I've been myself in many cases using stuff I didn't need Korvac comes to mind some people in the audience are like remember that mistake of mine? you know but it is not very useful for a lot of people but this particular thing is incredibly useful

for the SQL case and the SQL case is, I do not know what I'm going to be talking later to and I need to construct the perfect statement the correct expression and I can do it at runtime at runtime I don't know what it is, I mean at compile time I need to determine that at runtime now, what you saw here is basically a simplified reflection emit

this is using reflection emit to generate the code on the fly jit compile it and compile it to code as you're doing it you don't seem convinced that seems like the reason to use it anyways, it's so exciting now, this is completely off topic, has nothing to do with this

but since we're here, we might as well do it I decided to add to this beast you know, every time that I put a value it renders it, right typically it calls the toString method and it shows you that but if you return an image it actually shows that so let me show you a little this is a plot function that basically takes a lambda expression, takes a double and returns a double

so I'm able to do you know, I'm able to do graphs like that in the interactive C sharp shell right, not very interesting, but you can do things like, you know, I don't know I don't even know the name in English for this beast, what is it called? parabola? what? yeah, but that's

It doesn't matter. These guys are Americans. MALE SPEAKER 2 In Europe, thank you. MALE SPEAKER 1 What? Oh, right. I thought my audience was freedom-hating Americans. So let me check this one. That looks horrible.

Anyways, you get the idea. Anything that you can turn in an image, this beast is going to render it. And it's a nice little use of the C-Sharp evaluator. As you can see, C-Sharp is no longer a statically compiled language. It can be used interactively. We delivered this before Microsoft, so just take note.

Going back to the innovation piece, it doesn't matter that we did it. Chances are when Microsoft does it, it's going to reach more people than we do. But just remember, we did it first. And I want to say, let me tell you a story. It's a little bit of a conspiracy theory, but I was sitting next to the program manager for .NET one day and

said, you want to see our latest hack? And I showed him this thing. Like, holy shit. So he emailed Anders Helsberg and said, do you know that these guys have a REPL for C-Sharp? And he showed me Anders' response, and Anders said, well, that's a bummer because we want to do that, but it's not going to happen until code 11, which is

going to come in 2012. So we're two years ahead of them. And so at the PDC, Anders actually demoed his REPL stuff, which is not available to anyone yet, but he demoed that stuff to the public, taking away a thunder. I just want to put that out there. Make of that what you will.

Yes? Oh, all right. We're going to hurry this up. Really? Well, nobody's hungry here. So OK, so I'm just going to go very quickly here. The C-Sharp 4 features are very interesting. And in fact, I thought that this was just going to take

me like a third of the talk, so we have two thirds left. I'm not going to talk about this too much, but C-Sharp 4 has dynamic support, which means that you can now change the, anyways, everything that you heard about Aaron Ruby doing, C-Sharp 4 does now. Who needs that language?

Moving on. Now again, this is very important for everybody. Not everybody's happy with C-Sharp like Ivan just showed. Programming choice is a little bit like sex position choice. Not everybody likes the same. So I understand if somebody wants to use something else.

So wow, these people are hungry. Let's stop for two minutes, so if some people want to leave, just leave the block so we can go on. All right. Well, you guys probably already heard this. I'm not going to repeat this stuff. I'm not going to repeat this stuff. This was really interesting. I'm not going to repeat it.

This is fascinating in my opinion. This afternoon, perhaps, if you come to the Moonlight Talk, Alp Talker is going to talk about a very interesting development when it comes to compilers and C++. So you should come to that. I'm going to skip this. In fact, you know what? I'm just going to skip the rest. And we should just do Q&A after the session.

So thank you for coming.