The Changelog: Software Development, Open Source - Open Sourcing .NET Core (Interview)

Episode Date: December 10, 2014

Adam and Jerod talk with the members of the .NET Core team at Microsoft about Microsoft's motivation for open sourcing the base class libraries of .NET, open source vs source open, the true goal of open sourcing .NET Core, and this new Microsoft we've been seeing.

Welcome back everyone, this is the Change Log and I'm your host Adams Dekovic. This is episode 134, Jared and I talk to the core team behind.NET Core, that's Microsoft.NET CoreFX. Can't believe it, we haverosoft on here talking about open source of all things we were surprised to definitely a great show we have rich lander emma landworth and varun gupta on the show great great conversation about microsoft and open source and lots and lots of fun we had some awesome sponsors for this show code ship top towel and rack space helping us make this show possible. We'll talk about TopTal and Rackspace a bit later on in the show, but our friends at CodeShip always amaze us.

Continuous integration and delivery as a service. You can release more frequently, get faster feedback, and build the product your users actually need. A simple push to a repo runs your automated test suite and configured deployments from a simple deployment to Heroku to a complex deployment pipeline set up for large infrastructures. All that can be set up with ease using CodeShip. It integrates easily with GitHub or Bitbucket. You can get started today with their free plan. Setup takes just three minutes. Make sure you use the code THECHANGELOGPODCAST. Again, THECHog podcast again the changelog podcast and with that code you'll get a 20 discount for three months on any plane you choose head to codeship.io

slash the changelog and tell them we sent you and now on to the show All right, everybody, we're joined back today. We got a fun show lined up today. We got myself here. We got Jared here. We got Rich Lander. We got Emo Landworth. We've got Varun Gupta. Those guys are from the.NET Core team over there at Microsoft.

And I tell you, this is maybe an unprecedented day for us because in the history of this show, we've only had one show on.NET, and that was on NuGet. We didn't expect to ever have anyone from Microsoft on the show talking about.NET being open source. So I guess that's hands in the air on that one. But let's go around the table here real quick and give some intros. So, Rich, let's start with you, IMO, and then Varun after that in no particular order. Sure. I'm Rich Lander, as Jared said, or sorry, Adam. And I've been at Microsoft since 2000. I've been on the.NET team since 2003, and I've shipped each version of.NET since 2.0. It's

been really interesting being on the team and building all the technology that we've been shipping to customers that whole time. But this last little bit where we've been getting our open source project ready has been definitely the most exciting time in that whole period.

Alright. And we got Emo. Yeah, so I joined Microsoft in 2010. And I was a customer for a very long time. I was basically on the first beta basically since 2002, I believe. And so when I joined the team, I had very much a focus on.NET

from a customer perspective. And I'm super excited to see some of the things happening that we did over the last two years, in particular, releasing more stuff on U-Bit as well as our open source that we're doing now.

So it's really great times for me as well. Gotcha. All right, Varun, how about you? Hey, guys. I've been in Microsoft for about the last 10 years, mostly around.NET. I'm part of the.NET team,

which is doing the open source work around.NET Core. Interestingly, I'm also part of the team that's helping set up.NET Foundation. So it's very exciting for me from both fronts. You know, seeing back the last 10 years, definitely very exciting and a new path. But it's something we're all very excited about. So, Jared, I guess I'll open this show up with probably the most important question we have here. And to you guys, too.

I mean, congrats on taking this shift towards open source. I think you'll probably see and you probably have seen already the benefits of just the open source community interacting with a wider developer base maybe than you're typically used to with feedback and issues and GitHub and pull requests and all this collaboration that goes into building open source software these days. So let's maybe ask the biggest question here, which is why open source? And maybe even a tail-off question, which is why now? I will answer the first question. This is Rich, right? Yeah, sorry, this is Rich. I think the big key motivation behind why open source

is that we want to just reach developers who we can't typically reach with a pure kind of closed source offering. And there are plenty of folks out there that open source is a key requirement, and we want to make them our customers as well. So that's really the big piece. Do you want to tackle the second one, Imo? Why now? So the why now question is interesting. So in the blog post that we published two weeks ago, we basically sketched open source

as effectively two pieces. The first piece is cross-plat, which is if you think of any sort of serious cross-plat projects, and they all have one thing in common, and they're open source. And it's not that open source is the only way to do cross-plat work, but it's probably the most sustainable way of doing it because you can very easily incorporate other people that care about certain things that you either can't repo yet or you just don't care about this yet. So a good example is if you look at Linux, for example, when Linus Torval started this whole project,

he still didn't care about 160 architectures for him to target. But over the years, certain people jumped in that cared about certain architectures and then the breadth of the project significantly increased over time. And that's why it cross-played. I think if you look at.NET, the mono community is a very strong force there. So it would be very idiotic from our side if you wouldn't incorporate those communities and make it easier for them to work with us.

The second part of it is, if you look back for the last two years, we're basically doing more and more agile delivery. And from our point of view, agile delivery is really the key of making sure that the right thing's happening in a reasonable amount of time. Because the more complicated the project is

and the more design upfront you perform, the higher the chances are you get something wrong at some point. And our project is now almost 15 years old, if you consider the initial work time before it went public. So there's a lot of complexity in the product itself. So by us being able to deliver things in an agile fashion, that also means we get customer feedback way quicker. We also have happier customers because when you file a bug,

you live long enough to actually see the bug being fixed as well. So if you consider this in the previous time, like three years release cycles, it was often very frustrating for customers. And as I said, I was a customer for a very long time. So I found that back in 2004, they got closed as loan fixed in 2009 or something. So I can totally relate to this problem

that you just don't get feedback from Microsoft. So Azure really gives us this way of doing it. And we ship packages on NuGet for over two years now on our team. And from our point of view, open source is really just the ultimate version of being Agile, right? Because essentially every time you commit something, it's immediately live.

And in theory, it's consumable, modular and eBugs. So we get feedback pretty much in real time. So instead of having a customer discussion every two years and we ship the beta, we can actually have a discussion with the customer in real time. And that's why open source now makes a lot more sense than it did maybe 10 years ago. Seems like quite a sea change from Microsoft's previous stance. As you guys said in your blog post, it was kind of you open source to universal acclaim,

trending on GitHub. Anything Microsoft does makes a big splash. But I'm interested in how this change came about inside of the company because it seems like such a change in strategy that usually those things have to be sold up a chain. Whose idea was it, and how long has it been,

like, you guys trying to convince people, or are you the ultimate decision makers? It's clearly all Emo's idea. Definitely. Good one. I think on our side, we're all very intense right now. They basically say open source was my idea. But I think you said it's a strategy change.

I would agree that it's a strategy change, but I don't think it should be a massive surprise. I mean, if you look over the last, I don't know, probably longer years, I mean,.NET open source is not the first open source project that Microsoft did. The very first open source project was the Windows installer XML, and that's now a fairly long time ago. ASP.NET is open source for quite a long time now, and the managed C-sharp and BB compilers were also open source six months ago.

So there's clearly a progression where Microsoft became, I think, better at realizing what open source actually means. I mean, there's these bad quotes from Bulma like 10 years ago or something about GPL. But if you realize how we run with open source now, I think it's clear that it's not a shift that happened overnight. Anders Heilsberg, for example, the shift designer of C-sharp, he had a lot of experience with open sourcing as part of the TypeScript initiative that was open source from the first day. And he really

absolutely liked the experience that open source, designing the open, interacting with people in real time, was ringing because you could reach developers that we just could never reach before, right? It's really about the conversation and the sheer innovation speed at which you can take the feedback

and make something out of it. And I think in general, if you look at Microsoft around, I mean, Walmart had this vision statement of devices and services, for example. And especially when you look at services and we're in the same work that delivers Azure as well. So there's this and TFS

and both are services now. And so they're both on the very aggressive timeline as far as releasing small increments of functionality and then getting customer feedback on it. And from our point of view, the developer stack is something

that you really have to give in people's hand very early on in order to get meaningful feedback. But we can't just ship faster the framework itself on Windows because that just doesn't scale to 1.8 billion machines. You really have to have a way where we can give it to developers faster. And so on that point of view, I think that open source is also just the continuation of DevOps or some of the other keywords that you have probably heard. So you mentioned Balmer, and as we all know, you guys have had a change in leadership here recently. Is the timing there

coincidental, or was that change in leadership leading to this new stuff? This is Rich again. I do not think it was coincidental. If we look at the fact that

.NET supporting Linux and Office supporting iOS happened in the same year, I think that's clearly showing that we're trying to reach out to our customers and provide products on the OSs that they're using. So I think you're just seeing a shift in strategy at a fairly broad level in Microsoft. I have to give you guys credit too, because when you're embracing it, you guys really are embracing open source on GitHub, MIT license stuff, taking pull requests. I always compare Apple and Microsoft when I'm looking at strategies because I just enjoy watching you guys do things. Apple's still kind of just throwing their open source over the wall and just like, here you go. They're not really embracing it as a thing as much,

but you guys seem like you're really going for it. Yeah, I think that's something that we learned over the years. My team in particular, we did open source, or I should say source open for a lot longer than just the current open source strategy. There was the managed accessibility framework that we published on CodePlex a while ago. But

the challenge that we always had, that we basically did source open, where we basically give you the source, but then there is a lot of challenges around us keeping the community around alive because it's not really the real thing, where we give you every once in a while a drop of the source. And so the one thing that we learned over the years is that, first of all, that's just not sustainable from our side.

Because if you think of Microsoft as a company that delivers a bunch of products, then you always have these massive release cadences where, you know, towards the end game, you are focusing on fixing bugs, stabilization, all of that. And then the first thing that you stop doing is, you know, things that don't directly contribute value towards that goal.

And so from our point of view, like maintaining an open source site, Sambar as a site project, it's just not maintainable. It's the first thing that gets cut when, you know, people have to focus. So the only way you can sustain open source is if what you see on GitHub is the real deal, because that's something we can't cut.

When we stabilize and we have to commit to the same repository everybody sees, then there's really no option for us to discontinue that work. And I think that's also something that the community really appreciates, because I think in open source in general, and I think that's true in any community, it's definitely true in marriages, right? People don't want to get surprised, right? You basically want to have a trusted relationship

with each other. So if you get the impression that Microsoft is holding something back because we go dark for half a year, even if we don't do anything bad, it still has this very bad taste of us not telling you everything. I think that's something that I think we learned the hard way over the years. But I totally agree with your sentiment

that I was a customer for a long time. I pitched about Microsoft like everybody else. And one thing I realized internally is that if things change, they really change. I mean, people really embrace it and then go wholeheartedly with that vision. And that's why I'm so excited about open source because I think we no longer have any way

to back off from that. Now we are all in and I think this trend will continue. I like the term all in too, especially for you because like you said, when you make a turn or you make a change, it tends to be pretty drastic or it's not an easy shift. You sort of make quick decisions when it comes to big turns like that

one thing you said that i'd like to camp out on for just a second was the flip side of open source i never really thought about and maybe this is a new term to me or just a new term in general but source open versus open source being pretty much the exact opposite where open source is focused on uh like jared said not pulling an apple or you're just throwing the code over the wall and hoping for the best and not really embracing the community. And can you talk a little bit about that shift, particularly with source open versus open source? And maybe I guess maybe you've already done that to a degree, but feel free to ramble

on source open versus open source for a bit. Do you have any thoughts on that, Varun? Yeah, I think we had reference sources up there for a while. They were under the reference source license. But it was basically one way. So what we, this time it's very different. We have resources up there and there's a lot of activity and we are basically two-way.

It's basically the real way. I mean, what you were referring to with Apple is probably what we were doing earlier. But the current effort is really about getting our stuff open source in a meaningful way. And as your question earlier, the mood in the.NET team and how we're looking at it, I would actually put it this way. There's a lot of excitement within the team, and that's're looking at it. I would actually put it this way. There's a lot of excitement within the team and that's reflecting on the repo. Basically

every day we have stand-ups and hallway meetings and stuff like that and chats. Everyone is super excited. We're talking about what's the next full request coming in and we're discussing about those and having a good time about it. I think all of that is kind of reflecting on GitHub, all the energy in the team.

The team in general is very excited about it, excited about the open source aspect. When you say team, Varun, beyond you, Rich, and Emo, who is the.NET team? How big is that? I mean, obviously it's probably large, but give the audience an example of how big your team is and the excitement size. Well, I'll just cover the team size. We have a lot of people working on.NET in general in the division. So we're in developer division.

And so we have a ton of people working on Visual Studio, on.NET Framework, on compilers. But I think your question is more maybe the size of the team that is working on.NET Core itself. That's certainly, well, with the team that released the framework libraries that you saw, there's tens of people that are working on that. And then the runtime will come later. There's some other set of people that are working on that. And then the runtime will come later.

There's some other set of tens of people working on that. So all told, I think you're probably looking at about 100 people working on the code base that's going to be available on GitHub. That's actually a lot of investment. If you're wanting to make a bet on.NET, you can see that there's a lot of people working at Microsoft to provide you with a quality code base. So let's talk about exactly which pieces of code are out there right now, because let's face it, y'all have a lot of software over there. And there's distinctions between.NET Core,.NET Framework, Entity Framework,

so on and so forth. If you go to your guys' Microsoft GitHub page, which I think is just microsoft.github.io, tons of repos. Kind of highlight the big ones and kind of tell us maybe what's not there yet. Yeah, so basically if you look at.NET Core, what you see today on GitHub is a very small number of libraries. We have immutable collections, we have the metadata reader that Rostan is using, we have XML, and we have our vector library that

enables SIMD intrinsics. The question is, why did we pick these four and not some other random slice? The reason is, as I said earlier, from first, number one priority is to make open source real. The thing that you see on the website is the thing that we can actually build ourselves and actually use the actual source to deliver the actual product.

And so there's some engineering initiative that we have to do internally to decouple or build infrastructure from the libraries themselves. And as you can imagine, DevDiv is super large, and we have 10 years of code base and build infrastructure that we have to decouple in order to make that work. So these four libraries that are out there on GitHub right now and.NET Core are essentially just, you know, the libraries that, you know, we could easily extract because they're the most recent ones we did. XML is certainly not the most recent one, but it was, you know, one of our few libraries that we could just say, okay, this is the one we can decouple very quickly. And so what you will see over time is that the entire.NET Core stack, which basically includes the runtime, includes the BCL

layer, includes networking, and also includes HP.NET on top as the app model, will be open-sourced. And so right now, as I said, there's a smaller segment in it, so you can basically watch us as we add more libraries. And I think over the next couple of weeks, there's, like, I think three or four libraries being scheduled for being added,

console as being one of them, data flow as another. And so there's certainly more growth. If you look at the other repos, as I said, if you look at.NET Core, it's, you know, one way to think about the CoreFX repo is it's essentially the BCL. And so the BCL is basically the libraries that everybody has to use. Right. And then you have ASP.NET,

which is essentially the, the modern web framework. This is on top of.NET Core, as well as the full framework as a, as a runtime option. And then you have Entity Framework and you have the, you know, the ROS and compilers,

which are not on GitHub yet. They're on CodePlex still. And so all these things in combination are effective with the.NET platform. And ASP.NET, basically, when they started developing ASP.NET 5, they already knew that they would go open source entirely. So they started pretty much working on GitHub from day one, versus on our side, as I said,.NET Core is still something that is in our internal servers, and we are extracting it as we go.

And so I think that should cover what's on GitHub. Now, as far as the.NET framework goes, we essentially have two stacks. And right now, if you go to the.NET blog, I just published a blog post about.NET Core and how it relates to the full framework. So you can think of.NET essentially on our side as being two stacks.

One of them is the.NET framework, which is the full-flavored stack that we shipped 15 years ago. And that is the one that actually includes desktop scenarios. It includes web scenarios. It includes pretty much every scenario the developer ever wanted. And then on the other side, you have.NET Core, which is essentially a fork. And so the question is, why do we have a fork? And the reason really is it has to do with our ability to evolve that stack.

So the Encore is essentially a stack where factoring concerns and modularity was a key concern from day one, versus.NET Framework was never a concern as far as deployment goes because.NET Framework was designed to be deployed with Windows as one monolithic entity, so factoring was never really a concern. But now when you think about the breadth of devices and the scale that it has to do, then the question really becomes,

how do we ensure that we have the same architecture and can evolve this thing over the time? And so when we did.NET Core, we really focused on that, and that's why we have two stacks today. And as far as open source goes, one of the key things that we need to focus on is being able to not just release source on a regular cadence, but also take contributions back.

And I think an open source project isn't really an open source project unless you can really involve the community, which obviously involves bug fixes and spec reviews, but it also involves actually taking code. And so the.NET framework, because it ships with Windows, it's pushed out by Windows Update, there's a super high compact bar for that. And the problem is once you ship on 1.8 billion machines, it's really no longer about whether

you fulfill your contract. It's also about the fact that you fulfill the implied contract. Because when you have apps running at that sheer size, then there's a lot of implicit dependencies. So even for us, it's very hard to evolve the full framework at this point because every time we make a change, there's this trade-off between,

oh, did this break somebody or not? And the.NET Core stack is completely designed to be app-local. So from our point of view, it's very easy to actually take contributions on.NET Core because it's very easy to reason about what happens if we take that source code. And so that's why.NET Framework, you know, we released parts of it that corresponds to

our.NET Core stack as open source on GitHub in the sense that it's an open source compliant license. So it's all using the MIT license, but we don't run it as an open source project. So we don't take contributions back on the full framework stack. From our point of view, the real open source strategy the GSM.NET Core, and that's where the focus of attention is. All right, let's pause the show just a minute, give a shout out to a sponsor. I want to thank TopTal for their support of this show.

You know, besides my personal experience with TopTal, Pure Charity, as many of you know, who've been listening to the show a while and those who are new, I work at a nonprofit called Pure Charity. And earlier this year, we had a huge need for several Ruby developers. And within a matter of weeks, Topda helped us find some of the best, and we still have them on our team, some of the best Ruby on Rails developers we could ever find. This show in particular, we're talking about.NET. We're talking to the team at Microsoft behind.NET Core effects, being open source and what they're doing with the.NET framework. But even you as a.NET developer

or someone out there who's trying to hire a.NET developer to join their team, go to TopTot.com. They'll take great care of you. You can freelance as a.NET developer. You can hire.NET developers. The full gamut, TopTot.com, tell them the changelog sent you. So.NET Core, you can hire.NET developers. The full gamut, topto.com, tell them the changelog sent you.

So.NET Core, you said the term BCL, I translated it as base class license. Or sorry, base class library. My bad, I was stuck on your word of license back there for a second. But am I right to assume that when you say base class library? Okay. So you used the term BCL there to talk about.NET Core. And you used the word forked too. So to slow down a bit for the listeners who are just probably like I am, asking a bunch of questions as they're listening to you, is.NET Core then a fork of the framework then?

And will there be a second version of the framework that's sort of open source and the.NET framework that's sort of proprietary and closed source that you control? That's kind of the model except that as I said, the.NET framework is super large, but it also has client technologies like WinForms and WPF on top, but

there's certainly also the BCL part in the full framework as well. And so when I said fork, I mean, you can think of it, we took the sources in the full framework and just packaged it slightly differently for the end core. And so one thing we did, for example, is changing the assemblies themselves or the physical files that actually contain the binary code. And that is basically done in order to support the new factoring goals.

And that required some changes to the source. So from that point of view, there are support the new factoring goals. And that required some changes to the source. So from that point of view, there are some differences in the API sets. But we still are fully committed on keeping a story where you can basically create libraries that run on either side. So you can only create a library that runs on full framework as well as.NET Core. So there is a compatibility story between the two stacks. But as far as evolution goes, you can think of it as similar to open source in general,

where you basically have the latest hot stuff is whatever the latest commit in the repo is. People can download this, build it locally, and run it. And the next step on our side is we release open source prepackaged as a bunch of NuGet packages. And so we ship these packages every once in a while when the team that owns the particular component tests that component and signs off on that. But that's a per-component thing. And then the next step is basically we take a bunch of NuGet packages

and effectively do the same thing that open sources with distributions. I mean, basically take a whole bunch of packages together and say this is the next version of.NET Core. And so a fourth step conceptually is porting the innovation that happened on.NET Core back to the full framework. And that is just from a machine engineering effort that is always somewhat lagging behind because, as I said, touching full framework is hard.

We take our responsibility on compatibility extremely seriously so we don't just roll the latest build out. And so that requires some delay, essentially. And so from that point of view, the core pieces of it are available as open source on the full framework, but not everything is. Do you have that written down somewhere? Because my head's spinning a little bit.

It sounds like a lot of process. Maybe your direct customers probably follow that a little better than i did but it seems like um perhaps some clarity on exactly how it all works do you guys have that document anywhere or somebody who wanted to get involved could go and say okay here's how here's what i can contribute with here's the stuff i can't here's how it all gets shipped is that anywhere yeah so as i said like there's basically two blog posts on our site that basically summarize them up. There's one on.NET Core open source, which is about two weeks old.

And then just today I published a blog post on what is.NET Core and how it relates to the full framework. And what are the differences between the two and how do we think about that? Gotcha. Awesome. Now, while I'm sitting here, you said the word forked, and this might be a fun tangent. You guys got some forks out here on your guys' Microsoft page. You forked Redis, you forked Node, you forked Docker. Safe to assume that you guys are building technologies on top of these open source projects in-house? Well, this is Rich again.

There's probably a little bit of clarification that would be useful here. Okay. So there's actually two GitHub – well, actually, there's multiple GitHub orgs that we're using. Microsoft, the Microsoft org is the main GitHub organization that Microsoft is using, as you might guess. And so there's teams that we don't even know anything about necessarily that operate in that org. And so you said someone forked Redis. We actually have no clue about that. I mean, obviously we could find out kind of thing.

But we have like zero insight into that. I'm seeing now at the bottom of that page, there's other hype Microsoft GitHub orgs, and you guys have, man insight into that. I'm seeing now at the bottom of that page, there's other hype Microsoft GitHub orgs, and you guys have, man, double digits. Yeah, we actually have like 20 or 30 or 40 orgs. We're actually trying to move more people over to the Microsoft org to make it a little bit easier to navigate. But the thing is, our work is actually in the.NET org.

Gotcha. Yeah, that's where.NET Core lives. Actually, Varun can speak to this piece, what the.NET org is and why.NET Core is in there. So basically,.NET repo is actually the repo for.NET Foundation, the open source effort. You know, the open source community effort around.NET in general with the community. So.NET Core became open source. It joined the community as well,.NET Foundation community. So they were setting up a new repo. So basically, you know, we had a lively discussion,

and they actually set up the repo directly in the foundation. So that org, the GitHub organization, is.NET Foundation organization, and.NET Core has joined the organization and is basically doing all the open source work in the open. And Rich can talk about how Mono is also in there, basically actively participating in the discussions and the efforts. Yeah, what Varun was mentioning is we have a.netfoundation.org website,

and there's some forums on that at forums.netfoundation.org. And for those of you who know about.NET Open Source, you'll probably know about the Mono project. And so we're very much collaborating with that project, both in a code sense, as well as collaborating together and talking together in these forums. And if you take a look at the forums, you'll probably get a sense of that. And for those who are unaware, can you give a brief rundown of Mono? Sure. Mono is essentially a clone of the.NET that Microsoft built. I don't know the exact date of its inception, but it's in the early two thousands for sure.

And it's headed by a guy named Miguel de Casa, who actually had worked on some other open source projects. I think he'd worked on the gnome window manager. Oh, I'm correct on that point. And anyway, it's a project that a lot of people have used. More recently, it's actually been used to target iOS and Android as part of a tool set built by Xamarin, who Miguel actually works for. He's actually a founder

of that company. And the thing I think is really interesting right now is Microsoft, like the.NET team at Microsoft and the Mono project are now working closely together to kind of deliver coherent and consistent.NET implementations for all.NET users on the planet, essentially. And we didn't quite have that kind of an arrangement before. So I think it's really, really positive. And you'll see that. I think you'll really see that come together probably next year. Right now, we're just kind of trying to get everything laid out.

You know, this news of us open sourcing is also new to Miguel. So I think by the time we get, say, to the middle of next year, I think we'll have a much better sense of what it is that the two projects are doing together. We're very much still trying to figure that out. That's awesome. I think the cross-platform aspect

of this is going to be a huge win for developers everywhere. I fact-checked your gnome there and you drilled it. Okay, awesome. While you're talking there, I was like, I looked it up. Yeah, I do. I mean, we know Miguel personally, but I just wanted to make sure that was correct. Can we maybe camp out there for just a sec on the cross-platform thing and maybe just the fork thing and the open source thing?

I think it's sort of the summary of what we've been talking about for the last 20, 30 minutes. But what's the true goal here? Varun, you mentioned earlier cross-platform is a nice advantage of going open source. You mentioned embracing the community, embracing actually open source versus source open. What's the, what do you think, what can you share about the true goal, the overall goal of opensourcing.net

core versus keeping a closed source and not embracing community? So I think you meant me, not Varun, but that's okay. So I think from the other, the other, maybe I me, not Varun, but that's okay. The other Varun.

Maybe I'll lay it down. Was it Emo? Sorry, Emo, you take it. I think one of the challenges is, as I said, is that Microsoft is, as Rich mentioned, now certainly going out of more devices. I think the general realization that everybody in the industry

is now making is that there's no longer true monoculture. There's many device ranges, and they all have certain market segments. But in order to be successful, as far as an application experience goes, those span devices now. Even if Microsoft would say, we want to focus on Windows,

the reality is there's so many other devices and experiences out there that you kind of have to integrate into that's expected from an app standpoint, that basically requires you to support not just one thing. You can still say as an application developer, I provide the best experience or most of my features in a certain vertical,

but the integration points are the ones that you still have to deal with somehow. And.NET was pretty much from the get-go designed to have a single experience on a variety of scenarios. So if you look at the original design of WinForms and WebForms, for example, somebody really made sure that they are pretty much the same. Now, I would argue that for WebDev it was a mistake because it's not an event-based paradigm, but in the spirit of making things similar,

I think that it's still very much an important scenario for many people because if you think from an architectural layering perspective, there's always pieces of your code that you want to reuse across the devices, some business logic, some logic that does something in your app. And from a scenario standpoint,.NET wants to enable those scenarios. And that certainly means that we have to go effectively where the app has to go. And in today's world, as I said, there's Mac, there's iOS, there's Android, there's Linux. And so we have to enable the stack to go there.

From that point of view, I think that open source is really about increasing the breadth of.NET and making it easier for people to just stick to one technology if they chose to do that. But.NET always had great interoperability with native code, so if you want to do something else, providing an native UI, for example,

and then call into.NET or the other way around, there's certainly storage for that as well. So when we talk about cross-platform, I have just one question here for the listeners who are thinking like, okay, so what does this thing work on? What can I, if I'm hacking today, could I pull it down, start working on it today? What platforms are currently supported by.NET,.NET Core,.NET Framework?

That's the word I was looking for. The other F word, the good F word. I can take that one. That's the word I was looking for. The other F word. The good F word. I can take that one. This is Rich. Right now, both.NET Core and.NET Framework support only Windows. So just to back up a little bit, we've clearly stated that for.NET Core, we're going to support it on Mac and Linux as well. And so we kind of had a decision to make, which was should we wait until we've done all the engineering work,

at which point we support Linux and Mac as well as Windows, and then open source? Or should we open source with our Windows implementation, start to build a community, and then build the Linux and Mac support in the open. And so as you can guess, we chose this latter option.

I like that option. Yeah, I really feel like it was the right option, especially given the response that we saw. I think it's just been hugely validated that it was the right option. That's essentially what we're doing. So we do not yet have the Linux and Mac support, but we've already started working on it. We have people who that's their main job, is building Linux and Mac support into.NET Core. And you're going to see that start to arrive pretty soon.

Now, it's not going to all appear on one day. It's going to be very iterative. Is there one that's first before the other? That's a good question. I don't think we've made a plan quite like that yet. Well, what I would say is, in general, if you look at how.NET works, there are certainly things that are

inter-platform independent. All the collection libraries, immutable collections probably works today as it is already on any environment you know things that interact with the operating system like file systems and other things are obviously a bit more involved and then as you go to the lower stack uh you know we have this very you know thin layer that basically ties the the actual framework towards runtime and so you know on our side we basically have two different runtime strategies today. We have a JIT-based runtime

and we have an ahead-of-time compiled runtime. And so we also make investments to make the runtimes available cross-clad, but that's obviously something that is more like an all-in or nothing because you need the entire runtime up and running before you can actually run any managed code. So there's certainly some, you know,

some investment there as well. But as far as the libraries go, I mean you can probably already compile some of our libraries that are in GitHub, I would say that the metadata reader probably in some way or the other already works on Mono because there was a demo that Miguel did where the Majesty Shop

BV compilers, we used that component already run on Mono, mutable collections should just work and so I think the very first thing we probably do is, on our side, add the build scripts so we can actually build on a non-Windows machine

and then set up a CI system that we can actually validate for requests across the different platforms. But as far as the ability goes to just take the source and run with it today, you should already be able to do that.

The one thing I want to add is that, you know, it's always true that.NET was cross-platform if you screen hard enough because the monoboost was around for a long time now. But I think the real difference is now that we not only have a fork community where one side does the

Windows thing, which is Microsoft, and then there's this other community that does the Linux implementation. The intention of.NET Core is really to have one unified code base that runs on Linux, Windows and Mac. And not just that, runs on Linux, Windows, and Mac. And not just that, also on top of that, Microsoft actually says, we support these three things.

So it's no longer the case that there's a Microsoft distribution that is Windows, and then there is, let's say, a mono distribution that does Linux and Mac. It will actually be coming from one corporation, so to speak, as far as baking goes. But as far as the community goes, it's really just one big community where Microsoft plays one part in it. And then, you know, the Mono community plays another part and whoever else wants to join in plays their part. All right, let's take a break from the show real quick. We got to mention a sponsor.

That sponsor is Rackspace. Rackspace loves open source. They love supporting their community. And just one of the ways they're doing that is by sponsoring this show right here that you're listening to. And that's why they're giving you and everyone else who wants it $50 a month in credit for 12 months to explore their open cloud. Get a free Developer Plus account today

to get started. You get dev-to-dev support. So if you get complex questions, you can talk directly to their developers. They're the same experts who write their SDKs and their apis and get access to all their services monitoring dns auto scaling orchestration private networking message queues and more all for free there's no usage limits whatsoever so use their services as much as you want you're only billed for the usage above 50 a month they have open source libraries to support any language

of your choice. And for those listening today, they do support.NET. Go to the changelog.com slash Rackspace to get started. And now back to the show. Earlier on, you guys mentioned, I think, was it Imo who made the marriage analogy? I want to get back to that here. was it Emo who made the marriage analogy? Yes, that was definitely Emo. I want to get back to that here. Yeah, that was all about his personal life.

Varun was laughing his butt off, so Varun's got something up his sleeve, I think. I want to get back to that for a second because I love you guys' excitement. This is really cool stuff. The community jumped on it. Even Microsoft haters were like, wow, that's really awesome. And you mentioned how excited you guys are

for pull requests and stuff. And I would say you're very much in the honeymoon phase of open source where everything's exciting. You know, I've had that situation where I get a bug fix to my repository and I didn't have to do it myself. And that was awesome.

We spoke with a lot of people over the years where they've been maintaining open source projects for a time and started off exciting and they got, you know, a lot of press or whatever. And, uh, it was fun. And then over time it became hard work. Um, obviously you guys are doing this as part of, you know, your jobs, but running an open source project can be difficult.

It can be taxing. It can have moments where, um, have moments where this pull request is excellent, but it actually goes against our business goals. So there's all these different concerns. Were these things you guys thought about as you decided to open source? Yeah, I can take this one. This is Varun. I think here the culture of the team kind of comes into play. That's what I was talking about earlier. So when I look at the team, our engineering team, all of them are really excited

about open source. They feel like they're not just doing it as part of their jobs. I mean, if you look at the GitHub repo, how it looks and everything, folks are truly excited. The only difference is they're getting paid for it. So basically, that's why I think the excitement around open source

will continue here. There are obviously the kind of things you mentioned about, we have to think through how we are going to process full requests in a democratic way moving forward. How do we work on some of the contentious things? Obviously, as engineers, we tend to get into our discussions and stuff like that. And how do we kind of handle them with a broader audience?

So all of those challenges are true, but I think the true thing that makes me excited about this whole thing is the culture on the team. That's really unique. I was telling this to I is the culture on the team. That's really unique. I was telling this to Imo the other day that it doesn't feel like that I am working

in a team which my friends think I am probably working in. My friends are not from Microsoft. They think they're probably wearing suits or something. But here, I think the culture of the team is very, very very different truly excited and you know basically uh you know if i use the phrase living in github you're not wearing suits

then uh no we're not wearing suits t-shirts shorts flip-flops or what uh in the summer we'd be wearing flip-flops um it's pretty cold in washington right now it's true yeah it's just above freezing, so we're skipping the shorts. Well, I've heard the rule is if it's above 30, then flip-flops are okay. I thought you kept it so warm there as you wore your cold clothes on the way to work, and when you got there, you changed

into your warm clothes. Totally. I'd just like to comment on a question that you guys were asking earlier, back to the motivation piece. We talked a lot to the motivation piece so we talked a lot about the motivation for open source but we didn't um really address the motivation for cross black quite as much and um from a corporate customer standpoint we actually do get a lot of customers coming to us that say uh you know really love..NET, love C Sharp. It's very productive. We can build the

apps we want to with it, but we've got a bunch of Linux machines that we've been using and, you know, we're trying to consolidate our dev platform across everything we do. We want it to be.NET. So please build a Linux version for us. You might be surprised at how often that question comes through. Another one is that's fairly similar in nature. I think we've publicly stated that about 20% of the VMs in Azure are Linux now. And we very much want to be able to give a consistent offering of developer platforms that work on both Linux and Windows Server in Azure. You know, Azure will continue to have the model of, you know, it's your VM, run what you want on it. So we're certainly happy to have people running Linux VMs that run Java on them or whatever.

But from a first-class offering standpoint, we want to make sure that people can run.NET apps on Linux, on Azure. And so those two kind of things are really the cross-plat motivation for us on the server side. You mentioned your corporate friends, so that's a good lead into the question we told you we were going to ask you about just the change that this imposes to your corporate users who either didn't use open source purposefully because they wanted to use something that was proprietary and had support or had something to blame basically if something went

wrong. You know, how does this change things for those corporate users who may not embrace open source or who purposely didn't embrace open source for whatever the reasons were? First, I think there's a first answer, which is we're not really changing much about what it is we do. As you can imagine, we've always had source control. And so really all we're doing is taking our source control system and hosting it on GitHub and changing the license to something much more liberal. So that's the open source thing. But we're not changing anything about our internal processes for how we go about shipping quality commercial software. There's nothing really about that that's changing. And that's definitely a strong message we want to send our corporate customers.

The other side of it is if you're uncomfortable with open source or just don't care about it, you don't really have to think about it because you don't have to participate in the open source community if you don't want to. And what we ship at the end of the day is still commercial software. Most for the foreseeable future, most of the code base is still going to have been written by Microsoft engineers. I mean, we certainly want to get to the case that a very high percentage of pull requests come from the community, but you're fundamentally still getting a product that was vetted by Microsoft and is supported by Microsoft support. So I think for corporate customers, you can still think of this very much as Microsoft commercial software and call it good. Awesome. Well, as you guys know, we usually close out with a question about a programming hero.

Now, all three of you, feel free to answer, but I know at least one of you have somebody in mind. So who is your guys' programming hero? Yeah, so from my point of view, I already mentioned, I was a customer for a long time for Microsoft, and the reason I really jumped on.NET when it came out was the fact that I used Delphi quite a bit before. And I found that Delphi was an amazing experience. And then the guy who did pretty much Delphi went to Microsoft and did C Sharp. And that's Anders Heilsberg.

So from that point of view, he's somewhat my hero in the sense that it set my career and influenced my decision to join Microsoft. As I said, many people here, I didn't join Microsoft. I joined the team that owns.NET and that happened to be Microsoft. But if that would be any other place, that's where I would have been. Awesome. Anybody else? That's good enough for me, personally. I don't know if Varun has an answer. Bill Gates? Anybody?

I'd say Vondermore then. You heard it here first. Another question that we tend to ask, which I think probably is apropos for you guys, is a call to arms for the open source community. You're speaking directly to the open source developers here today. What would you say, how can they help you, or what would you love for the open source community to do with regard to your new.NET open source stuff?

Yeah, I can take that one. So the one thing you just mentioned is the honeymoon phase where everything is awesome, right? We will certainly, like my team, although we certainly talked to a bunch of other teams around here that did open source and already way past the honeymoon phase, everything is different. Every requirement is different. So some of the stuff that we're working on are things like how do we do API reviews?

How do we decide something is good or not in a transparent fashion? And so it is very likely that we will do mistakes. We will not be as transparent as we promised we would be, or we will miscommunicate certain things, or we will just annoy somebody by closing their pull request. So if one of those things happen, then we absolutely do want to get feedback from the community and we want to have a conversation about that. And if you go to the forums

at.NET Foundation.org, there's already a whole bunch of people talking about how we do open source, what we do well, what we don't do well, what we could improve on, what we should do differently what we don't do well, what we could improve on, what we should do differently. And that's really, for me, the primary feedback that I am looking for.

I mean, there's always people that want to do pull requests, but it's from all the people that we reach. It's the minority. But a lot of people benefit from the transparency. And so that's the thing I really want to get a handle on, whether we do a good job or not. So you mentioned.NET Foundation a couple times in the show. It makes sense to mention here at the end that we do plan to have you and Beth, or sorry, Varun and Beth on an upcoming show to talk about the.NET Foundation and what that is. But can you talk a little bit about

just a snapshot of what the.NET Foundation and what that is, but can you talk a little bit about just a snapshot of what the.NET Foundation is? You mentioned earlier that CoreFX is granted to, I think is the word you used, to the.NET Foundation. What does that mean? What is it? What is that foundation? Yeah, that's a great question.

So basically,.NET Foundation is an effort which is to aggregate the.NET community kind of basically together. There are a lot of projects that are happening in process, like some of the new ones that are coming on board, like.NET Core. So the idea is to kind of have a common place where we can kind of advance the community at the same time together. It is a community-driven effort. It is being bootstrapped by Microsoft at this point, but it is going to be a community-driven. It's its own entity separate from Microsoft. Its advisory council will also have people from the community. So the whole idea behind.NET Foundation is that.NET Core has joined the foundation. Many other projects

have joined the foundation and they're actively contributing, working with each other in the foundation. So for all the new open source developers or the current open source developers, .NET developers are exploring open source. It's a great place to bring your projects, work together, and kind of contribute in existing projects or make your new ones with the community together.

There are a lot of advantages that come from working together and growing a community. So, the Darknet Foundation is that one attempt. In the upcoming podcast that we'll do, we'll talk more about the exact specifics. But in terms of call-to-arms, we'll talk more about the exact specifics. But in terms of call to arms, I'll recommend, request everyone to visit the.netfoundation.org website and learn more about it.

There is an email address where you can get in touch with us and talk about your existing projects, some of the new ideas you're thinking about. And I want to mention too, only because it's timely, we don't usually timestamp our shows that much to a degree, but you've got, as Jared mentioned, you've got some change happening in several open source, large open source communities where you've got corporate partners and sponsors that have sort of been paving the way. And we asked a couple of questions around your choices with.NET Core and some of the future we can expect in open source. But I think it's worth mentioning just because of this tail off to.NET Foundation, the fact that at least what I see now is that your approach towards the foundation, a lot of good open source is built around a foundation versus a corporate entity,

sort of open governance and the community is what you mentioned there. So I think from what I'm hearing, it sounds like you guys are taking the right steps to go towards Linux and Mac adoption for development platforms, open sourcing the platform itself or open sourcing, you know,.NET Core and the BCL, as you mentioned before. So congrats, definitely on that. Can you maybe mention anything else on that fact that, you know, it's about community, that there's nothing that's sort of like Microsoft and then versus the community.

It's sort of just based on this foundation. Absolutely. And maybe tease the fact we're going to have this upcoming show with that, you know, tease the fact. I completely agree with, you know, the summary around that it's very important to build open source projects around a community rather than a corporate entity. And that's what Foundation aims to be. And I think it will go a step further..NET projects that are going on and, you know, aggregating them at the same place so that they can connect with each other and sort of, you know, cross-pollinate and, you know,

participate in various projects. And this kind of should, you know, accelerate the whole.NET community as a whole. You know, as Imel said previously, we are all in into this. And the only way we'll be all in if all the community works together then some guides from here Well I know that Jared and I are definitely excited to have you guys

on the show we appreciate you coming on the show Beth sorry you couldn't make it but we'll definitely catch up with you and Varun on .NET Foundation and dive deeper so for those listening with bated breath on that one stay tuned. That might happen in the new year. I'm not sure if it'll happen before Christmas or not.

We'll definitely do our best to try. But Rich, Emil, and Varun, thank you so much for joining us today on this show. And thank you to everyone behind you, your team behind you, making your appearance here on this show and talking about.NET Core and what's happening there possible. I know you've got a lot of excited people that are part of your team that are, you know, lifting you up and, you know, doing lots of great stuff. So really appreciate all the effort that goes into making your appearance here today come true for us.

And we're excited about it. So I do want to mention before we tail off, we've got a couple of sponsors that make this show possible. CodeShip, TopTile, and Rackspace. Some really great sponsors we have on the show, so we very much appreciate their support. And with that, unless there's anything else, let's all say goodbye. So goodbye from me. Goodbye. Goodbye from Rich.

Thanks for the opportunity to be on the show. No problem, guys. Thanks for having us. Yeah, thanks, guys. This is Varun. It was exciting to talk to, guys. Thanks for having us. Yeah. Thanks guys. This is Varun. Uh, it was exciting to talk to you guys. Thanks for having us.

Thank you. I'm out.