.Net Foundation .Net Community Standups, 8 Aug 2019

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Languages & Runtime: .NET Community Standup - August 8th, 2019 - Null Reference Types

Description

Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET Core, Languages, CLI, MSBuild, and more.

A

A

I think no way actually like I pressed the wrong button, as it is usually the case when.

B

I'm confused anyway, so.

C

Welcome welcome.

A

To what is it the 5th 6th 7th? Can we just stand up for dotnet language, and one time with me today is Kathleen.

D

Dollard its program manager and working on languages and sealion SDK for Donna core yeah.

A

I'm in Landreth I'm, a program manager on the platform team, so I focus on libraries api's and getting this guy in check that job. My.

C

Name's Joe, Carter and I do some stuff with languages and tools. It's.

A

On screen, so today we have a few things we want to talk about. Hopefully, today is shorter than last week, because last week was Chevy said little bit long with 90 minutes, and we.

D

Were we were worthy? We were.

A

D

A lot yeah I'm, not sure that we we're gonna, try to say more with less words. This time I mean.

A

Yeah, that's a that's a bold move, given that we started 2 minutes late already. So let's start with something quick and if you follow a block, you probably have seen our server that we published yesterday. So if you are a dotnet developer, which probably you are, would be my guess and you're both in desktop applications, then you should fill out the survey.

A

So we go to our blog and the survey is just here's, this big fat link, you can click and it should take you between 3 and 5 minutes and it's a relatively quick survey for us to figure out what kind of applications you are building, what your pain points are and what you would like us to do. Moving forward in the desktop space. So just a quick pitch for the survey.

A

The other thing I would like to talk about really quick is as well I published a post yesterday on the dotnet standard adoption. So, as you probably know, we have talked about that in Senate for quite what did the two years? No three years now, and so this is basically a blog post. That summarizes where we are with adoption on new georg. So the quick summary is about 47% of the top 1,000 NuGet packages, excluding Microsoft and dotnet itself, because clearly we are supporting and Senate already.

A

So we just look at community projects and 7% of them in the top thousand already support on internet. That is great. Ideally it would be a hundred percent, but you can't have it all and then, if you look at all of New York it's about thirty percent.

A

So if you look at the trend lines which are generously added, you know, then you can extrapolate that I, don't know by 2022 or something we would have a hundred percent utilization, but you probably never get because on every package is still maintained, but the idea is that we would hopefully get to a much broader support for that net centered. But this is totally great, and the blog post also reiterates what you should do, because there still is some confusion. Given that we're about to ship dotnet sent a 2.1.

A

So in case you wonder which version to target you should still target 2.0 for the most part, because it gives you the most reach and most of the API additions that we added not less than a 2.1. You probably don't need if you need them, then by all means target dot and sender to one, but you probably want to do- will target at least for an ascender tool as well, so that you could still support on all the platforms, particularly donut framework, so that one is also done and now I.

A

Think Philip should talk a little bit about his blog post. Well,.

C

I actually had one question actually legitimate. Oh my.

A

C

Dotnet standard one dot, X actually still considered, supported or not. Oh yeah,.

A

So that's a question that I think comes up quite a bit, so usually what we have of all platforms story, my donut framework and net core there's support policies with version numbers right and usually at some point, all the versions drop out. Don't and Senate is different in that there's no implementation for us to support I, don't and Senate is just an API said and so supporting a smaller API said is obviously free of work for us right. So in that sense we do support it. Yeah.

B

A

Basically, we will always support all the way back to door and senate 1.0. The question was: should you target 1.0, and the answer usually is no, because the amount of the platforms that you would additionally reach a standard 1.0 over, let's say 2.0, probably doesn't make a difference in your day-to-day life unless you're still rocking a windows phone or something it probably doesn't matter. So in that sense, you're, probably better off targeting tool, because you get more api's, but it is fully supported, always remain supported and that's true for future versions as well.

A

C

Works I mean in the F sharp core binary. We recently have switched from that standard 1.6 and that standard to Dido welcome.

A

To them one on one: oh.

C

B

C

Is great so well cuz cuz! We because the LTS for dotnet core was until like and like mid-june.

B

C

Something like that, I don't forget, but and we needed to work on that right. So yes, no.

A

I think it's good, like I mean in general speaking, donor Center tool has other benefits for.

B

A

The package closure is small and other things, but and then, of course, the dotnet framework compact mode, where you can exhume, couldn't consume existing binary ever and not build for donor center, yet yeah anyway. So talk about this. None of a reference types thing yeah.

C

This is a little essay that I wrote basically yeah, there's a lot going on there I think, rather than go.

D

Through the entirety.

C

Of the very long.

D

Do you want to just scroll that for seconds give people an idea, I mean.

B

D

It over here- and it is it's- it's got a lot I'm, not saying long in a negative way. So.

B

I only have one I just want.

D

To say that this looks like it goes into some really good stuff, including marking your you're, including marketing, your own api's, which is something we really haven't, talked about before yeah.

C

Yeah I kind of intentionally wanted to go into the weeds with this one, because I think.

B

C

Was successful in doing that yeah, so there's definitely a lot to cover here. I think the the very high level piece is like it's pretty much at the very, very top, the the feature from like our Donna coreos perspective and like the compilers perspective or like the languages perspective, it's pretty much locked down at this point.

A

You want to first say what it is, because yesterday I saw another people on Twitter that apparently never heard of the feature. So oh yeah. What actually is it.

D

Line that have checked in with the in the in the chat room, I just want to say hi thanks for being there, no questions yeah, it looks like people just saying hello, yeah,.

C

I actually wish that we called it no ability, rather than normal or effin stuff,.

B

Oh there's so many names we might.

C

Because it's not really about reference types, because it also includes value types and compiler analysis for them, but the the whole at least the biggest idea is in the past string. What carried an implicit null you know, string, wasn't actually string or.

D

Any other reference to.

C

Any using string as an example here, we're, like you know if you have, if you take string as an input you're, not actually taking in string as an input you're taking in a union of either string or null you.

D

Know you sound like an f-sharp programmer and.

C

That's yeah well and that's what it is right like it's, but the thing is it was implicit right. It was either string or null every single time, and that's the sort of thing that you know in isolation with very small snippets of code. You would understand to account for it every single time and it was probably okay, but over the course of you know a code base with a million lines of code, there's a very strong chance that you absolutely did not account for every single one of those times. Yeah.

D

That's why some of us have seen no reference exceptions once or twice once.

C

Or million times yeah like it, we we fixed numerous, no reference exceptions in the Rosalind codebase in core FX and our compilers. Like you know, we still do it a lot and like we like to think that you know we have a pretty good handle on the languages that we build and understand when things could be knoll or not, but we even still miss it, and so, like I mean everybody misses them all the time.

C

So so the whole point is very explicitly distinguishing between a reference type that could be null and a reference type that isn't null that is or a non knowable reference type as it's called. So some people in the community who've been like following this stuff, have been saying: oh, it should be called non knowable reference type, so is um which is kind.

D

Of evening is just like the naming we were so far down the rabbit hole with that name that there, but by the time it was clear that that that we would have that we would have spent more time on the name which it was. It was an idea. It was an experiment. It got rolling at avalanche, we've got it it's a huge feature: we're really excited about it, but yeah that the name is very imperfect. Something about that. You know yeah.

C

And so there's um there's a whole lot that sort of falls out from from that being able to distinguish in the compiler between something that could be Nolen, something that is not at all and this this post kind of walks through all of that and like I, mean there's, there's the really basic stuff which I didn't cover because other blog post have where you know. If you have a string as input, and you know you dot into it, it's fine.

C

But if you have a string question mark as input and you dot into it, then could the compiler emits a warning, saying: hey this isn't safe. You should consider checking for null first and that's like some really basic stuff, but then the scenarios can get a lot more intricate, like you know, you may want to write generic code where you want to. You know, enforce that the types that you're substituting with are non null there was up until you know the preview seven released.

C

There was no way to like really effectively express that, and now we have the non null that are sorry that not null constraint where you can apply that to to you know your generic type parameters and in this case there's a TN and a T out. You know you, can you.

B

C

Any number of them and then you just say, hey it's not null, and so, if you were to try to instantiate that.

D

Might be a little.

C

Thing this yeah there we go so like you know, I have this interface here called I do stuff, taking and inputted an output and then I have a single method in it that produces that output, given an input but say now, I'm going to constrain it to be not null.

C

This is quite helpful because if you scroll down a little bit and you're gonna have to kind of scroll to the side on there, if I try to implement that interface and I'm, also going to need to constrain that implementation like if I, don't explicitly constrain these generic types to be not null on an interface that says that the types are going to be not in all the compiler emits a warning and then, if I try to instantly like instantiate, you know and substitute say, like a concrete type like string question mark again, I'll get a warning because it's saying hey T is supposed to be not null, but in this case you're giving me something that could be null, and so you again like this, this sort of stuff this.

C

This gets into more advanced scenarios, especially for library authors who write more generic code. Yeah.

D

One thing we should mention is that in the midst of these previews, the compiler team and the work that's been done on, the design of this feature is way out in front of visual studios. So basically it got done without much concern for visual studio and they are right now working to implement the support you want so especially in the previews, and even if we wind up with in 16.3, not being a hundred percent sure 100 percent, there there's definitely work going on to support things like, for example, I.

D

Don't know if you implement interface right now, whether or not you're going to get those constraints, but the.

C

Spectrum point: you: will you.

D

Will get those constraints already awesome? That's great yeah.

C

Where it gets a little bit, tricky is with the attribute analysis, so.

B

C

A whole bunch of attributes that I go over in this blog post that are for more advanced scenarios like, for example, say I want something to be non knowable for an output, but I want an input to be knowable or the other way around right.

D

So just it I want to just clarify something on that. So the nullable flag is a it's just a boolean flag. You know you're either going to be in a not null. This is expected to be not null, or this is expected to perhaps take a null, which is very, very black-and-white, and it turns out that there's a boatload of gray areas and some of those we found when we were working on core effects and trying to implement.

B

D

About core effects, we found a it's just boatloads of scenario well,.

C

D

C

It just turns out that the c-sharp language is really complicated. That's that's really what it boiled. That's really what it boils down to like I mean there are things that you can express, c-sharp and patterns that exist that, like they like you, you can't lift like a type system sort of safety mechanism.

C

Just onto these patterns, the c-sharp language would have to be far different to actually support that sort of stuff, and so that's just sort of a reality of the situation, and so there are many patterns where, like you know, you want to associate like, for example, string dot is null or empty. If that, if that fails, the check right, like you know, if it returns false, then you know oh well, it wasn't Knoller empty, so I can probably proceed, but that's just some method call that returns some value, that that really says nothing about.

C

You know its input. It's just a method, call where I passed an input and I got a value out of it, but there's actual meaning applied to that in terms of how people use it so right.

A

There's basically, if you think of it, what the compiler does right, there's a flow analysis portion to the compiler where, when you say, if X is not now, then do something and then of course you want the compiler to understand that under the if the value is not no because you rolled it, this way right. There's.

B

A

Api's, like is null or empty, or you know, try parts without arguments very easy, but but there's an implication of what happens when, when the return value has a certain radio right and so.

D

We're gonna fire a parameter: I will just step back just a second make.

A

Sure to add, like one option, would have been that the compiler special cases all of those framework methods, but that doesn't scale and also doesn't allow us to include third-party libraries right. So the idea was, how can we? How can we have a type system? That's expressive enough that basically, third parties can encode their patterns as well as the framer can, and so the and basically that's where the custom attributes came in right. We wanted more control over.

A

Basically what the patterns are in the API is- and it's kind of you say language but I think is really the combination of the libraries everybody has been using the patterns everybody has been using and the type system of c-sharp itself so.

D

What I want to be clear on here is that string is another.

D

Empty is ultimately a method in the the in core FX and that's where the attributes it's is on that method, and with that attribute sitting on the method, then user code can just forget about that, and it does what people expect, because, obviously, if you call, if is stirring a null or empty, and that returns false, then obviously inside the conditional inside that, if it's not know so, I just want to be clear that that these attributes generally go on library code to make it to make everyone else not have to worry about it, and it's completely open.

D

The work that happened in core FX was done in a way that anyone else's library can also be annotated with these same attributes. So I just want to be clear. Who needs to worry about these attributes? Is it's primarily.

B

D

Authors, yes, not people that are looking at this feature and I, don't think. That's.

C

D

C

I think everybody should probably be aware of them, because a complicated enough codebase effectively has many libraries inside of it. Oh.

D

I agree with that, but in some companies you've got people that are doing day-to-day code, and yet people are working on libraries and, if you're, working on day to day code on that day that you're just writing your normal code. This is this. You don't have to worry about this one and the reason I want to call that out is because it is. It is a a big feature to get your head around, but the attributes can come later. You don't have to jump in immediately and start worrying about what the attributes are.

D

So this poster is great because it does go into the weeds into the details that a lot of people really are ready for right now we're gonna go live people want to look at their libraries. They want to look at this deeper in their code base, but this isn't the 100 level blog post. This is definitely.

B

D

300 level blog post for folks that already are starting to uptake this and are running into these problems. I.

C

Would also argue that I, don't I'm, not even sure 100 level, blog post is possible for this sort of feature without you know like basically, the reality of people's code would far eclipse that 100 level like in an instant that they would immediately need to jump to something 200 or 300 level.

C

We're like you, know, oh, why did I get another warning by fixing this one warning, like you know like if you have an interface and an implementation mismatch, and then you have something in the body of one of those implementations and then you fix stuff up so that, like you know it conforms to. However, you want it, but then that now mismatches between the interface definition, you fix the warning, but you injured new warning as a result of fixing it and that's not like a bad thing right.

C

That's just sort of saying, like that's like a coherence sort of like you know. Oh hey, there's this other part of your code base that is sort of defining things, one way and you're not adhering to what that's actually stating and.

D

That's a point of the feature.

C

Right that is part of the feature, and but that's why it's it's I mean there. The I think it's good to be honest about the fact that it's difficult to like it is a challenging feature. Yeah just similar to how like async, is challenging right, like you know, it's it's sort of impossible to do these sorts of things and not think about it. But you know all of a sudden. You don't have no reference. Exceptions. Unexpectedly is a big deal. Yeah.

D

So we talked a lot about just that that aspect, which is super important, but I'm, really excited that big code bases in particular will be able to express internally what is expected on a very, very regular basis. So all of the reference types will be making a statement about their null ability all the time. That's.

B

D

Feature is and I think that that's going to add a way to comprehend code. That is, in addition, even if you had perfect code today and it never threw no reference exception, I think the still brings value to the table just because you've got that intent clarified on a regular basis. So.

A

D

Won't make as many mistakes in the future yeah.

A

There's something I want to talk about for a moment like so the first blog post talks a lot about what, basically, you can know do with the feature, but the one thing that we should also call out is what we have them with the feature ourselves. So by the time doesn't quarter your ships, not all of dotnet core will be annotated, in fact, not even all of corvex. Your.

D

Expert an annotation means yes,.

A

So effectively it's where the question marks are right, so we so we did B. We have reviewed basically the core library of core FX so far, meaning that is the area where we reviewed the API so said, okay, which things can be null which things commit.

B

A

Know I think it's out of core FX, which is basically all the api's you get when you create a console tab by default. We have about 20%, I notated I. Think okay,.

D

How many, what's the count on that? Just let people know how hard.

A

You think it was amazed here, I forgot the number, but I think it was like 18 hours worth of reviews. I think it's about it's about 20,000, API. So.

D

Sometimes no word of 20,000.

A

Yeah, something maybe 12,000 I forgot, but.

D

Over 10,000, it's.

A

It's a lot, and so basically what we have is we literally review to every single API and if we have in the framework and what you just said like it's the first time we can actually Express malleability at the API layer, and once you do that, you realize how inconsistent the API is are so, for example, in reflection. There is plenty of methods that accept arrays.

A

Where we said all the array can be: no, that's fine and it just means empty right versus all the other parts of the BC I'll usually say we talk about collections like I, new mobile or arrays null is London supported, available and equal events. Some methods return arrays. Sometimes we return empty array. Sometimes we return null arrays right and you realize that if you do that, like E, it's not so much the fact that people get my reference, exceptions is also the federal people cannot really reason about what what you know. What do you mean?

A

You know what the semantics are, what you expect to have right and so I think this is one of the areas where I'm actually kind of excited that we can now talk about null ability and null values in as part of the API review, but it also means you know. Phillip has this little section here when I want to quickly talk about this.

A

We talked about that ability know being part of the API so before it was just behavior of your code and, technically speaking, if you start stop accepting now, it's a breaking change, but now those kind of changes also reflected in your in your in your in your public API, and you don't have to make decisions about whether you know you're, okay, with those kind of breaking changes right.

C

And this is also somewhat like. We don't have like an official policy document as far as like how we're doing it, but this is sort of the way that we're thinking about it is like once they're added. They are officially part of the API and we are being very careful about changing them. So like we'd, basically that that's an offensive way of saying we try to get it right, the first time so that we don't have to ever change it.

C

However, we are open to changing now based off of feedback, because we want to make sure that it's locked and stable for when we consider the full experience to be like ready to go for everybody in all contexts and.

D

We're 20% right now so.

C

It's gonna be a lot more coming.

D

In and every time a new one comes in, that's actually is gonna, be a breaking change for people that are so adding them is also a breaking change. I.

A

Don't wanna meet here on this, like even when dotnet core 300 ships stable the annotations, are still considered preview, probably even post, 5 or because we'd be back between 300 300 and three one will only have 20% of the core FX API sign, rotated right and then in five four. We hope that we do the the rest of koreff X.

A

This still probably doesn't include you know: winforms WPF, asp net right so realistically, until the entirety of dotnet is annotated, it will probably take us probably until dotnet 6 will be right, I guess or something like that right, because it's just enormous number of API is right, but, like I, think the core of X AP has a probably stabilized in the 5 hole time frame. So I really hope that we don't have to do make breaking changes post.

A

You know 500, but the idea is that some of the API is it's not so much getting them right in the first place. It's also. Some of the annotations are opinions rather than what's.

D

Gonna ask you about that? Where did you line on a string yeah.

A

So two string is a good example right. So string is a virtual method. Clearly, the intent is that it doesn't return. Now, why did you read the docs and if you think about what you use it, you.

B

A

You probably don't want to return now. The problem is that people override it and some implementations return us some do not right so now. The question is: if we mark it not now that basically means we say we're. The consumer of the api's will not get a warning when they dereference the string.

A

Over-Riders will not potentially get a warning that says you're supposed to return it or not value, but now the questions is that feature helpful, considering that we already know, even in the framework of some cases where our implementations return now, and so we said, ok, we probably model reality rather than the intention, meaning. Okay, we mark the API is returning a nullable string, because that's what a significant amount of implementations do today and so, but that's an editorial opinion right.

A

We think it's more useful for us to annotate it as nullable, given that we have 20 years worth of history of people overriding that and return it now right.

B

A

Implement the API from scratch: today we were probably market not, but but that's kind of the trade-off right.

D

And if you marked it not null and somebody done it off of it, they would not get a warning which.

B

D

Point of the future, if.

B

D

Then, if somebody returned an awl and gave them a null, they would get a no reference exception, because just to remind folks is, this is not a runtime feature. This is a compile time feature that we're doing everything we can and I think we're gonna hit a really high percentage yeah, but they're still gonna be problems, and you would just be setting people up for failure.

D

Yes, if you had said that this was not no because it would be a lie, so I think that that's one of the things for people to think about is their annotating. Is that not lying is a good idea, because if you, you know.

B

It's a life skill, but.

D

You know it's if you had told people it's not know, somebody would get in over successes. I.

A

Agree with that, I also think that you know, if you just go over the question, when some person is asking Kimberly, is there a way to automate the annotations and when we started, we actually looked into those things, and we also.

D

Have done that, we.

A

Spent out of time on it and like we also talked to the jet prints, guys who implemented malleability on there and way before we had an hour and so they're, basically like the resharper, offering has effectively a bunch of sidecar files where they imitated the framework or their understanding of the framework, and they probably would some iil analysis tool that generates that and actually open sourced them. So they actually under jetbrains slash annotations on github, and so we talked to them and we actually thought about.

A

Maybe we should start with those as a starting point, but the problem is the annotations are very different from ours. So, for example, they don't talk about. What's null, they talk about.

A

What's not now right, so they they they they they have a kind of inverted from what we have it then the other thing is ours is, is, is a true type system feature right, so meaning in our case you can actually say ienumerable of nullable string or an alibi enumerable of a non null string right, there's was just based on input and output positions, so this parameter can be null or this method which our major came in now, and so the amount of mismatch that we had and that they had was just too big.

A

So we had to do it manually anyway and then same thing on our end, we originally actually thought about. Maybe we down to the implementation. Maybe we just do the API service like the ref assemblies, and then we said well. How do we know that they are right? We think they are returning or not, but we actually don't know, and so we basically said no, let's actually do it from the implementation and from first principles.

A

Let's get our code base to actually use malleable in the implementation, with the compiler actually validates that our statements are correct and then we bubbled it up into the API surface right and once you do that. Well that really you really give up an automation. It's just a manual process, yeah.

D

A

When we look at core library, we literally said I think Co library was about 800 files or something, and we just took the files and said this developer. Does these files as well, but that's those files and then we just try to get through.

D

A

D

That's a good yeah mark. We're sad too mark said on the stream that the 2-storey thing makes him a little sad. It makes us a little sad. It also reminds us of if sort of the rails been working inside of so we have this fantastic platform. That's been going for 20 years and has evolved in some really really positive ways, but at the same time, and because of that, we have to respect this prior art a very deep level and that's.

B

D

Why that decision once why we talked about that decision, but yeah it's it is, you know if we were writing a new language, we would have done it differently and if we were writing a new language, we wouldn't have 99% of what we've got and because you know, if we started with zero, we would only go so fast and so we've really we're sitting on top of a real and.

A

It was the trader from.

D

A

Right like if we had this discussion with Mads and the runtime team, every said: okay, we want to evolve c-sharp and the runtime, and if that gives us a better language feature, and so one of the discussions we had was, should we make effectively a breaking change and make malleable a first-class runtime feature all right, but.

D

A

The cost of this feature would have been enormous. It.

D

Was already expensive and.

A

And the on top of that, the question is really like: okay, if we make, if you make the barrier of entry so hard yeah.

B

A

Then how do people ever adopt this feature right and so there's a difference between a v1 and a you know: B 12 or whatever right? No, you controversion numbers and typescript had some prior art where they did the same thing kind of what we did except they did it sooner right, but they ship versions of types can provide a novel feature and then at some point is that okay, we have this feature now and yep.

A

It's a breaking change when you up into this feature and that's okay and they quickly saw adoption they're now granted typescript. That point was maybe here, maybe two years old.

C

A

Our end, we said it's, it's kind of the nature of the feature we'll be breaking if you opt into this, but we it's very clear that we have to model a world where part of your process is running with a notations part of the process of running without any notations, and so you have libraries that you have to mix and match right. If you go down that path, then you kind of land in the world where we are today where there are warnings and there ways to suppress them, and you basically think about and.

D

We and we wind up with us, with making editorial choices in the conservative side like to string that we just we just really couldn't break the world. The way we would have F to string had been no.

A

I, like the way mark phrase, I said a little sad.

D

Like I mean our.

A

Side that I would say we had some meetings where you.

D

B

Would be a massive.

A

Understatement they were, they were angry people in the meeting where one side was said that this shall be not no other people said no. No. This is not the reality, so it's actually a very hard.

D

A

Know I don't know yeah.

D

But I care a lot, but.

A

There's a reason we don't stream or design meetings.

D

Yeah and if you watch the ones that do get streamed every once in a while yeah.

C

D

C

Just haunts us every single time: it's.

D

So smokin, like an f-sharp program.

D

It's super important, we're very, very excited that knowable sacrament to fruition right now. This is a great blog post, I just.

C

Wanna say very quickly on sort of the very end of it is is, like you know, we're in I, guess what you could consider like: a knowable roll out phase. Now, where you know things are out there, the compiler and language is considered stable.

C

You know we're, there's, obviously more there's bug fixes that we can do and things like that, but the core design is in the court annotations for core FX are in and they are subject to a little bit of change based off of feedback, but for the most part, we're thinking they're, probably pretty stable.

C

We think this is a good enough time for library developers, especially to start at least trying to adopt the feature and if it, because if it's too difficult for them, give us that feedback and, like sort of say, like you know, hey I'm I'm, like I, can imagine a scenario where, like you know, say, system, dot link is not annotated right now yet, and they may rely on that. So heavily that they'll say: hey I really want this thing to be annotated before I can proceed.

C

Well, that's useful input for us in terms of our prioritization for like what to annotate next and when to release that and so on. So so.

A

There's one question that you're the best person to answer, and it's all it just scrolled off the screen- can I use c-sharp aid in a dotnet, send it to old library and I. Think you answered this in the post, yeah.

C

So technically, yes, in the sense.

B

D

C

That, if you like explicitly set you're laying version to aid, oh we're, not gonna, get into it.

D

It's like possibly it's, but it's not really supported. It's.

C

It's not considered supportive and that's because there's lower first of all, speaking of nullable you're not going to get any of the knowable annotations, because this just don't exist in that API set. There are more deeper issues, though so like. If you want to write code that uses async streams, it's not going to work because the types are not there. If you want to use range in index at all and c-sharp bait, the types are not there.

C

That's not going to work, and if you want to use default interface members, it's just going to fail completely, because the the runtime, like you know, say, nest, standard, Oh, sort of implies. This code can work on da net framework, for example. Well, don''t framework does not know what default implementations for interfaces are at runtime, so it'll just fail, and so like that's sort of like this weird subset of c-sharp bait. That's really accessible at that point, and so we kind of want to make the lines pretty clear about what is you know?

C

What is where is c-sharp bait like fully supported to run, and where is it kind of you know up the guardrails and if you want to go off those guardrails like we're, not gonna get in your way. Like you know, you can set that Lange version to eight and you can deal with some stuff, that's unavailable, and if that's fine for you, then that's fine, but so.

D

We're telling you a lot will be broken.

C

Yes, and so, and that can be tricky to deal with, which is why we think it's better to just say you know what it's done: a choreo nest an or 2.1, and you know I, don't.

A

Know that I don't I.

C

Don't know, there's amber and update. That's gonna support that standard yeah.

A

So one thing I want to say when we say broken, that we should be clear, honest, it's not you're running an undefined behavior, but this is.

B

A

Gives you a clear error that oh you're trying to use the range syntax I can't find the range type and you basically, the compilation, write similar different interface methods is not that at runtime, the runtime just crashes with you know an execution engine exception. A thing like that. It's just that the compiler will refuse to let you define them, because the compiler says I. Can't I can't know that the runtime you're running on actor supports. Do this and.

C

It's actually it's also not even defining I. Think there's like a weird. You know, inheritance based implementation scenario were like trying to implement something that that involves the default interface. Member can get kind of funky as well. Yeah.

A

I mean this I mean there's always cases where it gets interesting, but I think in practice like see the way you should think of seizure bait I think is it's supported a lot net cost vo support in standard 2.1 and then some similar framework and c-sharp right. If you upgrade the latest version of Visual Studio you take, you always got the latest version of c-sharp. We have stopped doing that because now the the if the feature gap is basically becoming bigger and bigger right.

A

We already announced it would only add new features and new types torrent framework. So there's no point in giving you the latest version of c-sharp. Now, if you really force it, if you said in the project file, things would work fine for the things that do work for and for the things that don't you just get a compile, error and I. Think that's! That's that's effectively the scenario you are in and as a dotnet standard library.

A

Also, yes, why we offer you're kind of used to the idea that not every type is supported everywhere, and you have to think about that and that's just yet another thing that you have to basically make part of your I guess: architecture. When you decide which platforms you want to support right, yeah.

B

D

Think that you mentioned one, that's super important, which is default interface method, so, if you're still supporting anything other than the the latest, then default interface methods run into a problem. They're not supported yet VB they're not supported in anything on framework they're, not supported in lower versions of c-sharp, and so you can run into problems pretty quickly.

D

It's going to be a great feature as it rolls in, and everything supports it, but that's a feature: that's gonna have a bit of a of a ramp up so that the things you're targeting who's going to implement your interfaces is also going to be able to uptake that feature. Now we have to put it in to start that process, but do be cautious in making sure that you know what you're, targeting in terms of language, in particular on default interface methods, so yeah make sense.

D

So there's dependencies on the runtime dependencies on the language, other languages that need to take up interfaces. There's several things in this. We sort of see sharp edges really increases the challenges on some of those things and the.

A

One thing, I would say is like nothing really has changed from the language integration into the frameworks. It was always been this way that you version of the language metric for a new forever functionality and, depending on what your target you may or may not get the feature, and the only thing that is no different is that we explicitly state that certain things don't go back to dotnet framework right and that's that's realistically. The only thing that has changed like implementation, wise, the compiler works the same way as before, and it so.

A

In that sense, it should feel very natural for everybody. That's.

C

There was also a blog post written about that earlier this year by Scott was at Donna quarters the future of dotnet. Yes, where it kind of lays that out very clearly I recommend anyone is sort of confused about that sort of thing and search for that blog post and read it. You know I think the summary states it best where it says new applications should be built on Donna, core Donna core is where future investments and done it will happen. Existing applications are safe to remain undaunted framework, which will be supported.

C

Existing apps that want to take advantage of new features and nets should consider moving to Donna core, and so that's a little trickier for library, authors but I think that does send a strong signal of like you know.

C

This is where the new stuff is going, and you know, there's there's gonna be perhaps a little bit of lag time because of the reality of where run times have to start sorry, the reality of where libraries have to work, but you know eventually say with Noble or say you want to include default interface members for some stuff, you're, gonna, sort of sort of have to draw a line in the sand and be like all right. Well, you know every past version, it all works.

C

You know maybe there's maybe there's like you know, we'll have like a support, contract or whatever for like an older version, for you know the consumers, who don't have these concepts and their runtimes, but then moving forward. This is you know where it runs for now and.

D

In that context, I want to say that we are expected to put default interface methods into Visual Basic, but not in three, oh yeah, so I just want to say that's the way. We're.

C

Not broken going the same thing with f-sharp E, you.

D

C

The actual everything actually works- it's just we haven't had enough time to like get it out in previews and let people play around with it so we're just holding off until and.

D

That's that's all a 4.8 for fresh sharp, correct, yeah.

C

Okay, oh no, sorry 4.7, but then it would be in a 4.8 release or you know we need to figure out the specific like.

D

C

D

Goes out with three oh four dot: seven 4.7.

C

D

And so for that eight is a future release. Yeah.

C

Or if we might call it five sweet we're not! Oh, never.

D

Mind soon, it's.

C

Gonna be done at five: oh yeah yeah. It's.

D

Coming out at the end on tip five, F sharp will have its next version, and the name is is TP to.

C

Bt yeah, but as far as dims default interface members go like similar, similar to VB like it's. It's there, it's stable. We, like you know we it's it's a major runtime concept that we just simply have to support, so you know we're supporting it, but we're holding off on just jamming it in and throwing it out there. You know, because we don't want to ship something that you know. Oh, there was a saddlebag oops.

A

Alright, then Kathryn has some fumes that do.

D

I got a couple things I want to touch on really quick, one of which it's too bad rich, wasn't here, because he actually broke himself with this issue. So I want to talk about it, so you don't break yourself. So, if you're working with a visual studio 16.3, which is currently the preview 8 that we're just getting out, then we're changing the way the Installer works.

D

Some of you may know that we have been for reasons that we've changed our mind on we've been leaving SDKs and runtimes on machines, and we've decided that visual studio should no longer do that, because it's making a mess of people's machines, and we don't have a good way to clean that up other than a lot of work in add/remove programs. So are you going to show people how many are on your machine? I.

A

Was about to say, like you said and miss, but I don't think it's that bit online.

D

It depends on how it actually has seen a machine that has.

A

D

Cleaned up recently, yes,.

A

D

I just like to point out: those are what all. Oh you.

C

Were talking about that's the case, yeah.

D

C

Thought you were marking upon Emma's personal hygiene.

C

D

Here's the effect of that there's a couple things on that. One is that in just preview, 8 2.1 is an optional component under individual components.

D

2.2 will remain an optional component, not checked, but 2.1 will be checked in the future, so you'll get it by default, since it's a long-term support version, but for preview 8, it's not if you want to don't want a 2.2, go into individual components and check it, and so at the moment, there's no entry in add or remove programs which has a new name and what's the new apps and features is that the new name? It's.

A

The quota ARB yeah.

D

Arp ARP, at any rate, that's there's not going to be an entry, so just warning on that: a preview 8i. This is totally cutting-edge. We're having a meeting this afternoon to finalize I sort of expect it to go back into a term if programs as a dummy entry, so that you just know it's on your machine, but since it has to be uninstalled or repaired through Visual Studio, then it's just it's not going to really be an actionable thing independently. If it goes on through Visual Studio.

D

The good side of that is, you won't break your your bill. You won't break your visual studio installation easily, previously you're going to add, remove programs and easily break Visual Studio regardless. If your SDK breaks Visual Studio, if you think the problem is you don't have the dotnet chorus, D K anymore, the visual studio wants the answer to that is always to repair visual studio. So that's just a important tip. We had a couple people here that made a mistake on that they made a big boo-boo, which was deleting your dotnet folder.

D

We do not recommend you delete your dotnet folder into Program. Files, just as we wouldn't recommend you delete anything under Program Files, that's generally something to be very cautious with and.

A

So is the idea then, like by default of the entries, came from you migrating the different versions of Visual Studio, correct.

B

A

Install them so it said either moving forward. If you keep updating with the studio, you don't end up with what johan calls you 40 to 45 installs of dorincourt. Yes,.

D

40 to 45 that you, maybe if those aren't previews, you may be setting a record because in general, what below that, if people haven't been using previews if you're using internal previews it's through the roof, if you're using only public previews, then that might be why you're seeing 40 to 45. But, yes, that's the problem and I have something for you in just a second. So we don't want to see 45 copies of the SDK on your machine of which one is probably being used. So we have been, you know very frequently.

D

Every quarter we've been putting a new SDK on your machine, we're sorry. So the next thing is that we're going to help you clean that up that we have a tool that will appear on the main major net pages. So you go and you say net and you would be downloading we're going to have it a link there to a tool to help you clean up your machine now, I have to tell you this. This is a pretty like it. You're gonna have lots of switches and dials.

D

It's going to be very easy to mess up again. Visual studio repair will fix Visual Studio we're going to have a Doc's page and I cannot stress enough. If you're going to use this tool, it should come up in the next week or two. If you're going to use that tool, please read the documentation. You can really. You can make yourself have to reinstall it DK's. It's not going to shoot a foot off. That's going to like be permanently damaging. It's just you're gonna have to repair your visual studios and then add back SDKs.

D

You need that's the worst. That's gonna happen, so it's not like the end of the world, but we don't want that to happen. I'm. So sorry.

A

D

And on top of that, it's a junk ah I'm! So sorry, okay! So anyway, that's going to come out. It's gonna I'm, really happy with what we've got done on that we. So if you have 40 to 45 right now on your machine, I'd suggest you not spend an hour and have removed programs individually deleting those but wait until you get that tool spend a little bit time with it.

D

If you're using global JSON, you want to leave those SDKs on your machine if you're using a version of Visual Studio, you want to leave on what it.

A

Was easy, I can't say: I, don't know dotnet space, one time, slash, uninstall or something yeah.

D

I think it's dotnet cleanup dotnet clean up. It is not a tool because it was very complicated to try to get a global tool running without taking off the run time that it was depending on and so that just turned into such a nightmare that we decided to make it a self-contained application. And so, if you absolutely have to run that today, it's available on on github but I'd suggest you wait till we finish testing.

D

You know it's kind of like unless you really want to be on the bleeding edge, so yeah, that's what we're doing on on clean up. Do we have any questions on that? We good I, don't say anything. I know.

A

Any question is always what I.

C

Think it's awesome. Oh.

D

It's awesome, it's totally awesome I'm, so excited and I. Think we've done a good job on it and we've we've done some eyes and cross some T's on that and I'll.

B

D

A shout out, we have an intern you trying that did that for us we have awesome interns here they do real work. It's great place to intern we're.

C

Really really happy yeah yeah.

D

A lot of people are really happy. We I I started telling people we will. We should do this, even if it's only in this building and of course we would never do it. Only for the people in this building, but folks that are running nightly, builds, have massive numbers and space time trying to get rid of yeah.

B

D

The I mention Global JSON. There are changes coming too close, Global JSON in three, oh I am behind on my blog post pologize for.

A

That preview 5- this is like a while ago.

D

What preview 5 is a global, Jason stuff, no.

A

Like the one you want, yes, no.

D

That's the real forward stuff. Oh.

A

This will hold that's.

D

A different thing: yeah Global JSON- it's been in actually for since not 5, but it's been in for a little bit. I am behind so I think we may have mentioned it, but we didn't go into the the core features of it, which is that our SDK selection is a little bit surprising when you have multiple patches, and so one of the things you'll be able to set is to use the highest patch. So if you want a particular feature band, so you want like 2.1 600.

D

If you want to be in that band, you probably want to run the heist patch in that band and you'll now be able to do that. You'll be able to specify an exact version, you'll be able to specify a minimum version, and this is super important for folks that are running github repos. Previously you either didn't use a global JSON and somebody might have an SDK below what you what you needed to run, or you included a global that JSON, and you were saying exactly that.

D

One which makes the people using your repo have to have exactly that one. So now you'll be able to set a floor to say that I want anything above 2.1 300. If that's what you you can use anything above that, then you can set that and then people can just whatever's on the machine. It's just going to work. You're not gonna have to be installing SDKs just to work with particular repos super big deal for the way that repos actually work in the real world.

D

So that's exciting any questions on that cuz I got a couple more things that.

A

There was one question, I think was.

D

A

What the tool try to scan for global adjacent entries to warn as specific as the cases turn.

D

No, there is a possibility. I had my first global tool was actually a global that JSON a finder in reporter and then, when I did, that I ran and found out how much work I was doing on parsing, and this was a year and a half ago, and so I started working with John sakera on the system command line. That's that was the inspiration for system command line, but I set the tool aside.

D

I'm I have, I will probably revive it and then what the way that we have in mind doing, that is that the the cleanup time can take a response file, and so we would have a separate tool that gave you a list of the global debt. Jason switch. You could edit, if you wanted to, you, could mess with if you wanted to, and then you could pass that as a response file into the cleanup tool and that's the way we've decided to do that piping.

D

So if you get a list of your global that Jason's by hook or by crook, you write your own tool. Somebody else beats me to it and gets a global tool. Evaluator out there, whenever we get that done, if you have a response file with the individual ones that you want to leave there, then it will take the response file. So I'm pretty excited we added that feature, and that was because a system command line made it easy.

D

We actually I actually was looking at this problem and I asked John I said: hey John, do we do responsible yet, and he goes oh yeah, it already works I'm like oh, so we already had that feature without even trying. So that was pretty exciting. I got two more things. Real, quick. The easy one is is for all the visual basic folks out there hi love you and we will.

D

The my feature is not going to be available in 3.0 on net core, so dotnet core will bring forward a bunch of visual basic stuff that we've been doing the Visual Basic runtime, but we ran into problems extracting WinForms from the my feature, and so while it was actually there in preview, 7 we're gonna have to pull it out in preview. 9 and my will come back in probably in in it's gonna. Come in a future version, I don't want to promise I'm hoping that's gonna, be 3 1. So we're still working on that, though.

D

So that's a visual basic thing and one last thing: tools: authors for all the tools. Authors out there, I love, you too I mean I'm so happy that we have the uptake. We do on global tools and we're trying to just start calling net tools, because you write the same tool, but the way somebody installs it on their machine may be a global tool, a local tool or a tool path tool, so I'm trying to start calling them dotnet tools.

D

If you have a dotnet tool, I am sad to say that the that they are normal framework dependent applications when they go on the machine, which means that they're going to follow normal role forward. Behavior, there's nothing special about tools and what that means is that they will not roll forward across a major version boundary. They will not roll forward to 3.0. So if somebody takes a tool that targets 2.1 and runs it on a machine that has 3.0 only on it does not also have a copy of 2.1, the tool will fail.

D

So what you need to know about this is a yes. This is coming and B. There are three solutions to this problem and you'll have to pick the one that works best for you one is, you can put a runtime configure the roll forward option and that's what was in that blog post. You tried to bring up earlier. It has a roll forward option, so you can say just keep rolling forward.

D

I, don't care, just I trust, it's going to work, and so you can say just roll forward across major boundaries and then it will work on three. Oh it work on five. Oh, it will work forever. Assuming that nothing, you called has a breaking change. The second thing that you can do is you can multi target? You can say target 2.1 or 3.0. That's the second thing you can do, and the third thing you can do is to document that you require the older runtime on on the computers that your global tool is running on.

D

So that's coming. I am very sorry. We don't have a blog post out that on that to give Moorehead us more lead time to people to get there, but that that is coming in the future, the near future of tools. So that's that's! What's on my agenda for today, I wanted to get those out there they're all kind of like not perfect things work to do, but I want to get them out there. Is there any questions on any of that I.

A

Think there was some discussion on unification of dependencies, but that's kind of like I, think just a side, conversation yeah.

D

A

All right, so it seems like we again took the full.

D

A

C

There anything you haven't covered should cover so many things. Oh.

D

No I mean is everything that's like the stuff I was covering. Is things people really need to know today? No.

A

I'm just saying like last time we said, maybe we should shoot for half an hour, but I guess.

D

For an hour, I.

A

Think we'll never know.

D

An hour hour like.

A

We have so much stuff, you have languages.

D

A

D

Dotnet and it's all about net core, it's all of C sharp. It's only BBN, f, sharp, it's all of the SDK and CLI it's it's Emmett's built. We haven't talked about that recently, but maybe next time in.

A

Fact, since we do not currently have the audience, I would like to see people comment and say what they think about our direction like your 60 minutes good, or do they would they prefer something much much shorter? Okay,.

D

So we have one person who says they'd like the full hour. Somebody said we didn't talk about f, sharp enough I totally get that we didn't talk about a lot of things enough and always.

B

Thought more about it! Alright, so.

D

For right now, we're gonna start aiming for an hour where last time we thought never half was too much and so I think we probably should be looking at any final comments. Anybody have pressing and it's fun to do this by the way. Thank you all for tuning in and joining us because we're having a lot of fun doing this. Okay.

A

Hey just talk about all the things all.

D

The things good beer for week and a half and then only stopped because we got tired. Let's talk about overload resolution. Oh that's.

A

D

Languages, it's.

A

At or incomplete a rhythm, what do you want.

A

Yeah no I mean it's interesting for us to basically talk about the stuff that is top of mind because that's usually the stuff. You want people to give us feedback on right. So that's why we I think used is mostly to to share our thoughts. You can get people to either respond to block polls, take surveys or tell us what.

D

A

About the feature, because once we shift it's hard to change and.

D

This is what we're excited about, so it's great fun to be able to share it. Yes, I think.

A

If you also I think it's more to sing for the audience if we are excited, if we are bored, then well.

D

If we were bored, you have the wrong job. So ya know we're excited about what we do.

A

Alright, so I think that's all we have for today, then I, don't know whether the github announcement is still going on, whether we just with that it also just did one hour in case they haven't. Therefore we have a recording, so are.

C

They still gonna still.

A

Doing it, is it the full day I, don't.

C

D

I'm sorry I'm out of the loop I.

C

Don't know like time we announce the package registry and, like some CI, CD stuff, I see I looked at their page for total supported, run times and environment and it was hilarious. They like every dot net, SDK and I'm like.

A

C

A

What can I say? It's.

C

Like hundreds of.

A

More dotnet, all right, then I say bye everyone and then hopefully we see you in about a month and then by that time, hopefully Katherine and I coordinate our clothing better. If you don't look like.

D

A

It's a it's a it's a dotnet Hospital.

D

To my back to my chemistry days, I'm just I say.

C

It's more fashionable than a lab coat. It.

D

Is I'm just saying that it is you can't tell on screen I'm looking at that going up, this look like I walked into hey.

A

A lab coat is super fashionable you look like a smart person. Alright.

D

We got stopped alright, alright, thanks again.