.Net Foundation Design Reviews, 26 Jun 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: GitHub Quick Reviews

Description

00:00:00 - Approved: Guarding calls to platform-specific APIs https://github.com/dotnet/runtime/issues/33331#issuecomment-650326500
01:21:00 - Approved: OS compatibility analyzer https://github.com/dotnet/runtime/issues/37359

A

A

A

All right good morning, good evening or wherever you are um so we are reviewing today platform certificate apis uh and how we model them. uh I might be slightly biased in this review because I proposed the api shape, so um I will try not to impose myself too much because it also will take me taking notes which looking bad was probably not a good idea, but also helps me to focus.

A

So I don't know who was on this thing last time, but, like I mean just, I will just start from the get-go so that we get all on the same page so effectively. Let me just scroll down here so like we just go to usage first and then we can focus on the apis later.

A

So basically there's um a few things you want to get out of this, so it starts with the fact that, starting with dot net five, we have new tfms that allow you to target uh particular operating systems right. So the ones we envision are windows, ios android mostly uh for now, and so the idea is in the project file.

A

You say something like net 5-ios 12 and then you may also say something like tiger platform min version and set it to 10, which basically means that you will still be compiling against the ios 12 sdk, meaning you will see all the apis that were introduced in ios, 11 and ios 12 as well, but you still want to run your app on ios 10, and so what that now means is first of all like with this project configuration, we would like to record these decisions in the resulting binary, which we already do today with target framework.

A

So there's the string that core app comma version equals 5.0 as we burn it in today, and we would extend that to also generate target platform and minimum platform uh attributes which are both new. The attributes don't exist, so we will review those and that's the string that we envisioned to record because it basically mirrors the string that's in the project file.

A

Then we basically also have the idea that well now that you see the ios 11 and ios 12 apis. How do you avoid a situation where you accidentally call new apis without intending that? uh You know everything compiles fine and you run your app on ios 10 for the first time and then everything blows up.

A

So we don't want that. So one of the things that we have for this is the idea that first of all, you should be able to check whether you run on the platform. So there is a platform guard uh we already have today.

A

Runtime information, dot is uh os platform and we would basically add a new api is os platform or later where, basically, you can pass in the platform and the version number, and we basically tell you whether you're running on this platform or not, and we would do the version comparison for you, because we know historically that people are really bad at formulating version. Queries apparently, and so the idea here is that we also have an analyzer that will honor this.

A

So the idea is, if you write the code naively meaning you just call the ios, 11 or 12 api directly, then basically, you will get a warning and then, when you actually write the platform guard on top of that, then the idea is that the analyzer is smart enough to not give you a warning. So this way you're not accidentally calling newer apis, and you can also do the correct version checks in your code.

A

Then there is the you know slight side effect of that. So the question is, first of all, how does the system even know that this api here is specific to ios 14, and the answer is the the uh the api will be attributed, and so the idea is that uh the assemblies that give you access to the os specific apis, which we call os bindings, will have attributes pretty much in every single api. That will tell you which version this api was introduced in and our analyzer will use those attributes to give you the warnings.

A

However, these attributes are not restricted to just the you know the os bindings themselves. You can also apply them to your own code, um and so we already saw that earlier here is that the minimum platform version is already burned with the assembly as well, which basically means the the idea is that your entire assembly will run on ios 10 and then the idea is also you can say. Well, maybe there's an os api that is hard to call.

A

So let's say you want to write a wrapper type around that that you use by yourself in this case, what you can do is you can just mark your wrapper type itself being a platform specific which no means in in your methods that you have. You will not get any warnings, because you already said this whole type can only be used when you're running on ios 14 and then every part in your code that would use this wrapper type. Will now also have to do these version checks.

A

So basically, what you do here is you just forward the version requirements to the consumers of the code that that you're authoring, and so that's, basically the the quick summary so like this? Does anybody have any questions on that so far.

A

Okay, that means no, then let me scroll all the way back up and then say these are the apis that we are proposing. Maybe let's start with the with the attributes, probably should have reordered that, um because, hopefully that's easier so there's effectively a few attributes. So today, uh target framework attribute is already in systemruntime.versioning.

A

So that's why I'm proposing we put all the attributes there as well and.

B

um There's a hand raised michaela and kayla.

C

uh Yeah, so I don't. I don't, have a question so much as a fundamental um concern, which is that uh in the original platform in the in the original os minimum version um and made a deliberate distinction between platform and os because there's a kind of overloading of of the operating system version and the api version and that distinction. It does have some important consequences um and I'm not really sure how to message it to developers.

C

But the fact that you can compile against uh an api version and that really doesn't have a that. That is, that does not have a hard link to your os version.

C

So if you're saying your minimum platform version, that sounds like it has something to do with the api version, but it doesn't. It has nothing to do with the api version really.

A

That's right so, like yeah, I think I know what you mean, um so we can talk about this, maybe in more detail, but I think to me the I understand the concern you have. I think in practice, though, I'm not sure it makes a huge difference, because the idea is that uh from a user standpoint like these things are syntactically very similar right. The fact that they are semantically different, I think, just kind of falls out in the way you um you use them right.

A

So, basically, if we go back to the to the to the sample code here, so you're basically saying like I want to target something that gives me access to ios 12 apis. The fact that this is logically here, the sdk version or the os binding version.

A

I don't think matters much because the idea still is that what we put in this attribute here is effectively the version of the operating system that introduced that api and and logically you're, just comparing those uh for larger than or equal to right and- and so the idea is that I think syntactically they. They don't make a huge difference right, semantically, yes, but I guess that's just in the in the way the usage is being done. I don't think it will cause a lot of confusion.

A

Does that make sense.

C

A

Am I am I just not getting your concern.

C

That doesn't really align with what I've seen in reactions to the proposals um in the you know. If we have the in this, ms build example that ios 12 12 120 is the target platform version.

C

um That means the version of the api right. It doesn't mean that you're targeting it doesn't mean that you're baking any version into your app to say that it wants to use the compat versions for a specific api version, not for the specific os version necessarily like it might give you some kind of implicit bound, but it very much means the api version.

C

um Now, if you say target platform, minimum version that sounds like you're specifying some kind of range of supported target apis.

A

So I'm monetization what you're saying so you're saying the the the name of the attribute target platform is not great for this.

C

So target platform, min version has doesn't really have anything to do with target platform version. Target platform version is an api version target platform. Min version, as you have here, is purely a runtime thing right. It doesn't have anything to do with the api at all, so by naming them. So. Similarly, it sounds like it's a minimum api version and it's not a minimum.

A

So, are you talking about the name of this property, because this one, I don't.

C

A

Care like I just took the one because.

C

A

The one that already is in existence, so this one yeah yeah, I I personally.

C

A

Zero opinion on that, like if okay yeah.

C

I want to rename.

D

A

That is fine by me. Yeah.

D

And what do you mean by an api version? Because assuming that I understand how all this works, which could be wrong? The saying target framework net 5, ios 12- means if this is distributed via nuget like and if your something else is building for ios 11 it'll say that there's literally no asset in this package, uh because you failed to find something that intersects in the red graph.

C

D

C

What you mean by.

D

That that's a that's an os version, not a like. I just don't know what you mean when.

C

D

C

D

Platform and api versions.

C

Because the api version is the metadata so like you can build against the metadata for ios 12 and use exclusively ios 11 apis and set your min version to um 2 to 11, and it's going to run fine on 11 and you don't have to do any platform checks or anything like it. It's the target the target platform, the the target framework, is purely the set of reference assemblies. You have that you get to build against and those could be.

C

Those could be rev to have new apis that are in a new os version or they could be arrived to have newer, helper, apis um and so on, but they they affect the they affect the apis that you have access to at compile time.

D

Right, but they also affect what at build time, if again, assuming nougat, if you've said your target framework is net 5, ios 12, then something building for a lower ios version won't see that this has any like. The output of this compile does not exist on any ios lower than 12, because nothing's in the new package at that target, it would say this the you're trying to reference the thing that can't be built in the in the target environment.

E

It it it sounds like the concern is you you say. Your main version is, for example, windows, 19041, but you're only using apis from let's say 15086 or whatever the version is sure, in which case the app will actually run successfully on 15.086, even though you pulled in the win md file for 19.041, and so this sounds like maybe a potentially separate analyzer that should exist. That says you're targeting a min version, that's higher than the uh highest version of api you're. Actually using. Is that a correct summary michaela.

C

No, no, and- and I think I think I think this is beginning to reveal how like some of the confusion around these like they, they are just.

C

So there's a there's: there's a there's, a there's, a spec I wrote, which has a whole section on like the different, the the different version concepts and the relationships between them.

A

So, basically like, let me just summarize so there's the final sentence that there's three version numbers. This is basically what api level are you targeting right? This is basically like logically, the model that we want to more or less have is that people generally compile against the latest api version. Then there is the what what version of the os do you want to be able to run on, which is you know? uh Basically it can be higher than the api version, which is the normal mode that we are all used to right.

A

You compiled against something, although you run against something later right, that's easy! Then there is the model where you want to compile against something you know latest, which is the latest sdk, let's say, but you want to be running on an operating system that was shipped three years ago right and so what that means is you can't call apis that were introduced uh after that?

A

Os was shipped right, and so that's where this analyzer that we talked about here kind of kicks in and tells you when you're calling these apis incorrectly and then the expectation is you guard the call right and then there is the target version which is kind of like a you can think of it like like a clocking mechanism right when you look at windows, for example, we have this manifest file where you can say.

A

Yes, I tested my app for windows 10 or I tested my app for windows, 8 or 81, and that kind of controls how the operating system thinks about your app right. If you're saying my app was designed for windows 8, and then you run against windows 10, then maybe you get additional compatibility working from the os because they change some behavior somewhere versus. If you were compiled for 10, then they would assume that you tested on 10 and then you would get the right behavior, and so basically this is.

A

This is what the target version really means in our world. We basically like in dot net world. We only have one today, which is basically the target framework right, and so what we we're doing with the os part, is you basically say yep. You also be able to target the the operating system with the same mechanism.

A

This is what this des suffix here does, but but that basically controls is kind of like what you're compiling for right, so that that may give you access to the latest uh ios sdk, but you may still want to run on an older version. That's what this min version thing is doing, and then there is the you know the target version, which is the correcting behavior, which I don't think we have a representation for quite yet, but that's basically, the the the third version number.

A

F

C

Sorry is that a.

A

C

uh Yeah yeah the target. The target version is a concept that exists on android, for example, it doesn't exist on ios, so that one in particular is not universal, um but uh yeah yeah, so the so the api version purely affects. What metadata you get at compile time.

C

And the tag and the minimum os version purely affects what one os is, what os versions your pla, your um your application, is allowed to run on.

D

Right, so if you, if you built something with this project as described right now, what is nuget going to say, or what's it going to look like in the resulting nuget package? Is it going to carry itself as net 5 ios 10, because the main.

C

D

Overrides the where it goes in the packaging hierarchy.

C

It will carry itself as net 500 ios 12, because that that 10 version has nothing to do with the compile time and nothing to do with the assemblies. Yeah.

A

So think of it, this way right. So if, in the lib folder name, you will see this name here and so normal nuget rules will apply. So that means, if, if a consuming project has a target framework of net 5 ios 10, then you will not be able to install the package, because this package might use apis.

A

You know in the public surface new types they were introduced in ios, 11 or 12, which will now basically cause the consuming project to not even compile right. So that's why we give you an error. Now we will also carry the min version, but we will carry this effectively as additional metadata in the nuget package and then the idea is that, yes, there will be a rule in uga that will basically compare the min version that the package has with the min version of the consuming project and, generally speaking, it's okay.

A

If the consuming project has a a lower min version, because it means you can guard your calls into that library right and so that that's basically where, where this other attribute here comes in, because that just falls out, if you mark the whole assembly with this, it basically just means that the consuming project will get warnings if its own minimum version is lower than 10 right. And then basically, you just got your calls.

D

So is part of this that something in nougat resolution has to account for all of this.

A

Yes, so there's so there's multiple specs that we that we wrote and I have not done a good job of reconciling them. But yes, there's multiple work items on this and one of them is the metadata encoding in you get and then the resulting warnings that come out of that which is.

D

Basically, what.

A

The analyzer will handle implicitly.

D

I was taking nuget as invariant, which changes a lot of my assumptions, so uh thank you for that data.

C

So this this this this particular confusion has come up pretty much every time and I think I think part I think part part of it does come from the naming of the target platform in version because it sounds like it is related to target platform version right. It sounds like it's a minimum bound on target platform version, but it's not actually like it. It has an implicit it. It has kind of an implicit bounding relationship, but they're not directly linked.

A

Yeah so like that's, what I'm saying ignore the name here, because I just picked the one from the other one like what's more important to me in this work item here is the name of the attribute, because that's kind of what's proposed here, so that- and here you can see- I didn't use the name target at all, because it doesn't make much sense.

C

The the reason I had the reason- the reason I brought it up is uh so I do have a different name spec for the for the ms build property.

C

But if we go with that which is um which is os min version, then would it make sense for the set for the attributes to be minimum os rather than minimum platform, so that it aligns so that people can see that these two things are directly linked?.

A

So I would generally have no problem with that. It's just that, like basically in ms build the concept right now is called platform everywhere. So if we go with os for these things consistently, then I have no problem with also saying we that the attribute uses the term os over the over platform adjusted historically, we have used the term platform to mean os.

A

And so like, I'm not sure that we can, I mean, but that we can actually be consistent.

C

Yeah yeah, I I get that the I think the overloading is problematic. um I don't know how to fix the overloading issue that the overloading does cause confusion, that we have. This overload between the compile time metadata and the runtime os and those are different things which doesn't matter a lot of the time, but sometimes it really matters and when it really matters, it gets incredibly confusing. But.

A

That's related to targeting right. That's so that's not related to the term platform right.

A

Like to me, platform doesn't mean compile to metadata for the os I mean to me platform and os are kind of interchangeable terminology-wise, it's really more. The targeting aspect. I think that that brings up this thing of, like you know what what api versions do you see at compile time.

C

Yeah yeah so may so may maybe we should make the the hard distinction that target platform means compile time and just platform without a qualifier.

D

C

uh Or maybe os platform, given that we already have os platform the os platform enum may maybe we should go for os platform to mean like the runtime, um so.

F

That makes sense explicit there.

C

So we do like os, like minimum os platform.

C

Oh and- and we always have- we already already have like runtime yeah, so you have runtime information that is os platform or later so, if you just make the assembly attribute minimum os platform, yeah.

A

That works for me.

A

Minimum platform.

A

D

And I assume ms build is going to somehow address the complexity of target frameworks versus target framework and understanding the min version and how they relate and cross compiles.

A

Yeah, I think, there's.

D

A

Item for that I think michaela proposed that we have.

C

A

Level properties, so you don't have to like have crazy conditions on them, but like yeah.

C

Yeah there's a whole other there's a whole other um issue. For that that I would be happy to talk about, but let's not hydrate. This discussion.

A

Yeah so, like I mean you can kind of ignore ms build, I just give it here as in so that we have something to talk about really what matters is whatever the configuration looks like here. This information would like to record right, and so this is basically recording the framework name, which is basically the part before this dash. This is basically the part after the dash, and then this is whatever minimum. You have specified right right.

D

Well, I mean, I guess I'll, go ahead and ask the question now, instead of circle back to it later, but what I'm building up to is in this? Can we handle one or an assembly that itself like? Let's assume that there becomes a an actual semantic difference in the re rebranding of ipad os versus ios? Can you have the one.net assembly that says, assuming their versions don't align? I have minimum platform of ios 15 or ipad os 14 and that's embedded in the same thing.

D

Or do you now need to split compile to to deal with the fact that that changed and you can't do it with runtime information anymore.

A

So yes, and no so basically the the so you will be able to author an assembly like a single binary that will have apis for ios, mac, os and, let's say ipad os because they happen to be 80 overlap and then there's 20 difference. Let's say uh because the attributes are all multiple. You know you know, you know you can always apply multiple of them, so you can mark the whole assembly.

A

As saying yeah, I have a minimum os version for ios that is 10 for ipad os, it's 15 and for mac os, it's 9 or something right. um So that's possible. uh The problem is more here so like. If we actually have different. um You know different frame like basically different names for ipad, os and and uh um mac os, and then the problem is you can't really compile a single project for multiple tfms at the same time, right that like, if you do multiple tvms, you compile multiple binaries right.

D

Right, this would be if you did net 5 and then said by the way: ios 10 mac, os, 9 and ipad os 78.

F

D

F

D

Your tfm was just the I don't care or I'm I'm not a specialized, I'm a generic, but if you're running on a apple product, there are some extra concerns here. Yes,.

C

Yeah, so you could have a so you could have a platform neutral assembly, a net five or net six or whatever, which has annotations that say that certain apis are going to only be available, are only going to work on certain os versions, um and that might be because you use bait and switch. I your implementation was compiled against platform-specific um uh framework, um but but your reference assemblies are neutral. um Our tooling, for that is not super great, but it is a pattern that that is fairly common.

C

um That people use um another way would be if your platform, if your assembly is platform neutral, but then those your implementation of some of your methods depends on another assembly which itself has constraints on those, because it uses spate and switch yeah.

A

C

Just so another thing I want to point out is like.

A

In in.net today, both you know.net centered and net crab. We have apis that are window specific right. All the echo apis come to mind. Registry comes to mind right, so I would assume that we will use the minimum platform attribute on those so that when you use them and you're not targeting windows, you will get a warning.

D

Right so I'm just I'm just trying to understand the what the the big scenarios look like here, because that's important and seeing if the things feel like they're meeting the scenarios yeah. So so we do think it is important that you have a a target framework with a neutral tfm uh that does still participate in in some of the minimum platform stuff here, and then that means, if you're running on this platform. This is the minimum. But if you're not running on this platform, it doesn't apply.

C

D

C

Also factor um I I don't recall if you had this um uh emo, but there was definitely a suggestion that you could also annotate things that say it's not available on such and such a platform.

C

I mean the entertaining the reverse or the yeah like either we assume, if it's, if it has any platform specific annotation, then you assume any platform is not annotated for it's not available or if we have some explicit way to um mark them as not available on such and such a platform.

A

Yeah, like I assume the the former case right now for simplicity but yeah, I'm I'm not opposed to that. That's fair, that's defined, because I would. I would assume that, if you're platform specific uh you either are in in very narrow cases or the whole thing more or less is platform specific right, it's, it seems fairly rare that you have the inverse.

A

um All right, let's look at the attributes, so basically, what I have is here is: I have simplified this significantly. There was a meeting that I think I invited michaela too, but she couldn't make it where we talked about the encoding of the attribute.

A

I think jeremy was there bill was there, um I think reiner was there and daniel was there, and so basically one of the problems was before that we basically had the platform name and then the the version broken out into components, and there was a lot of discussion about why there we have four version numbers. It seems very awkward to to use.

A

uh Then michaela brought up independently of this, the problem that it's fairly ugly to put these attributes on stuff, because you know originally, if you look at the usage side originally we had things like you know: name of os platform, dot, let's say: ios, comma 14, comma, zero, comma, zero, comma, zero, comma zero, which normally these attributes are like extremely ugly to apply right, because they're very lengthy, and on top of that we have other pragmatic problems where the name of will return.

A

The name of the field, but the actual content of the os platform field is in a different casing. Then we have this problem with mac os right now, where it's not entirely clear to me that we will even have mac os as a member, whether we just reuse the os x one. So basically what we ended up with saying, like you know what, let's just ignore the whole version thing.

A

Let's just use the exact same string you put in the project file as one string and then if people aren't with magic strings, they can just declare like their constants in their project file and we use them. But then the idea is you only have as many strings as os as you're targeting. So it's not super busy and it makes makes this thing slightly more readable. And so, if we go down with that path, then basically the attributes all become very similar in shape.

A

So I just defined an abstract base type purely for grouping in the docs, so that you stand on this attribute. You can see all the ones that are derived from this there's one that we already talked about, which is the target platform one. It can only be applied to the assembly because it just records what the assembly was compiled for. uh You cannot apply multiple, because that makes no sense right.

A

Multi-Targeting means you produce multiple binaries and then each binary is just one slice and it kind of be inherited, because well it's an assembly level attribute right, and then we just- uh I guess this one you can ignore this is coming from here. I I edit the base type later so yeah basically know that this basically just derives from this. Has this platform name on it and then that's the end of it so and then the other ones are similar. So we have the minimum platform one um this one.

A

You can either apply to the whole assembly, which is what's done for the project as a whole anyway, but you can also apply it to anything. That is an api right.

A

So that's basically why it's class constructor event, method, module property and struct um module is probably debatable, because I'm not sure how much we care about multi-modular assemblies these days, but, generally speaking, I don't see why not um and then uh basically the idea here is if this, if this thing is applied to an assembly, it means the entire assembly cannot be called into from an earlier version uh by default. Right like it's still. The way the analyzer will work is that it will walk the api shape.

A

So if you call an api, that's not annotated, we look at the you know the the the containing type and then it's containing type and so on until we reach the assembly. So that means, if you mark the entire assembly, if you don't say otherwise, it means the api is only available on that version. You can still apply the attribute to the to the to a particular api to say this one is available earlier or later. So that's fine, because you just override effectively what that means.

A

But this is basically the behavior you get generally speaking, it makes no sense if it's lower, though, because if it seems a bit weird to say my project can run a minimum on 10. But then you have one api that can be called from nine, because that seems nonsensical. So by it by definition, you would usually just annotate apis with later versions um and then uh yeah, that's pretty much. The end of that does that make sense to people so far.

D

Well, so, just to be clear here that means that if you have one class that can be used to describe whether or not you expect things to run successfully, and it therefore has a a lower or in any consumption model, you can't use the assembly level attribute. You have to put the attribute on every other class in the assembly.

D

If you don't think it's a realistic scenario, that's fine! I'm just if.

E

D

Had the ver, their version of like runtime information is os platform within their their own assembly. They're going to have to do complicated, painting to make everything, work or use, ielt merge or well. It wouldn't be image.

G

They'd have to do a much more complicated thing.

C

G

Probably not going to be.

C

Every other api, though, because you will have some kind of baseline.

D

Right just, but there is no this, this is the default, but I'd like to break out of it and be more general. It's. uh This is the minimum and I can be more restrictive. Yes,.

A

Yes, because that's kind of like it, I your scenario makes sense in the abstract, but it doesn't make sense if you consider how we target things right, because you, you can't really build a an assembly like that today right because you have to put a target framework attribute in it. So, by definition, your whole assembly is at the very minimum it's tied to what it what you were targeting unless you specify otherwise right and the minimum just gives you a way to lower that.

A

But you can't really have a way to say: oh no, I make everything neutral by default right. That's that's! Not what we have that's.

D

A

D

Then, as a practical question, so I see that you have both the minimum platform and target platform, irrespective of what their final names are as sealed, but the platform attribute you have just a protected constructor on. Do you want that to be an internal or a private, protected constructor so that it's not third-party extensible.

A

So we could, I mean, I don't think it's a problem here, because they, this is just for grouping in the docs technically right, so like there's, not really an implication that an analyzer is supposed to handle all derivatives or platform attribute right. The analyzers will just look at particular leaf nodes right, so in that sense,.

C

A

Care whether somebody derives from that, but it's also probably not useful. Okay, so I mean I'm.

C

Okay, with making the constructor yeah makes sense to functionally seal it by default. If we don't have any actual scenarios.

E

What was the consideration for if the platform ever ends with a number- let's say hypothetically, they come out with wasm 2 and they decide to start that at version 1.

A

Yeah I mean like the this came up in the meeting that I had with daniel and rainier like the problem. Is today I'm okay with handling that, but to me that is not something that I want to just handle for the attributes, because we also have to handle it here right so like that would be. That would basically mean that we would have to come up with some sort of convention to separate the identifier from the version number, uh and that also needs to be legal in the in the in the actual tfm.

A

So if we feel like that's a real scenario, then we should design the tms differently and basically add a separator there, and then the attributes would just behave the same way.

E

A

E

That we come up with internally, so I have no doubt that someone someday will come up with a platform that ends with the number.

D

Sure, but we can do very terrible things and call it like w-a-s-m-t-w-o.

C

D

C

The platform end with the dash.

G

A

Yeah I mean like the the yeah there's, also the uh os 2 warp right, which you all know offer yeah. Frankly, you can just put warp behind the inversion number, so it's working, fine, um yeah yeah. I thought about this as well like I just don't think it's super likely, but if you ever have to, we can always refine the parsing. If you ever have to um like technically mac os.

C

um Like os x is os 10, so there's also the roman numerals approach.

A

Yeah, the the terrible naming that we do in this industry.

A

A

All right so then we talked about minimum platform version, so uh there's two more attributes which uh mckayla specked out originally, which is basically removed in and obsoleted in. So the idea here is that, because we have the model that we want to generally have a singular sdk moving forward, we don't want to ship multiple sdks right. We don't want to say: oh dot, net 5 supports you, know ios 10 and up so we have to ship an ios, 10, 11 and 12 sdk.

A

We only would like to ship the ios 12 sdk at that point and then just tell people like yeah. If you want to run on all the versions just put the mini version in there, but that no has the problem that, if apple ever removed an api, how do we do this? If our sdk model is basically a cumulative right and then it is well? You just put an attribute on this and says yes, this was available up until version 10 and then it was removed right.

A

So you would have a minimum and a removed in platform attribute on the api, and it tells you when it was introduced when it was removed and then same same thing. Our analyzer would would tell you that if you're, if you're running on a platform potentially greater than that version, sorry equal or greater than that version number, you would give a warning that tells you that well, this api is no longer there. So please guide your call and then obsolete is kind of similar.

A

It will behave like our obsolete, except that it's also has to consider the version number you're targeting um but same behavior. Basically, um I didn't put a diagnostic id here, because I I think of these as platform apis, so I'm not sure that that they wore a different diagnostic id, because that's something that apple would control or android would control, and so the best we would usually do is. We would just tell people like use the url, but otherwise we are now in the business of deciding oh yeah.

A

This obsoletion is different from this observation um and that seems kind of something we. I don't think we care to do, we would just say we would just mirror whatever apple and android and whoever else owns the sdk controls, and we would just mirror that.

C

Is might we want to have a message, though, so that people don't have to go look up the url if it's just something like use xyz? Instead, it would be handy to be able to surface that.

A

Yeah message may be interesting. My concern with messages because it's in the in the assembly we can't localize it and so.

C

A

The general downside with messages which is.

C

A

I think urls might make more sense, but you're right I mean, if apple doesn't get bothered with the url, then maybe the best we can do is we have just generic release notes for this release and we just list all the obsoleted ones, and then we can translate the doc page. If you want to.

C

I would say yeah, I would argue, um an untranslated message is probably more useful than no message.

D

That is fair. What's the, what are we expecting to happen for remove like so going with just the numbers we've already talked about? If you said your minimum is 10, your target is 12 and it says it was removed in 14..

D

um Should you get a warning on every time you call a thing that that has been marked as removed.

C

Because that's not possible, you can get her removed in 14 if you're. If your target is 12. yeah.

D

I thought we said we were just only wanting the one set of s like you could be running on 14., like no.

A

Not to know the things, this goes back to the confusion that that michaela was speaking about so think of it. This way here, so you think of it kind of how then reference assemblies work right. If you are compiling for net five, you cannot see apis in net six right, because we give you the reference assembly set that can only contain up to 5-0 right. So the the difference from the os version here is that think of our reference assemblies as also being annotated.

A

So when you target 5-0, we would also tell you yeah by the way this was introduced in four five or this was introduced in 3-0 right.

A

What we don't, although we can't support you in net, is we we, you can't compile for 5.145 right, because that's not how metadata works on.net for os bindings, though that works, and so that's why we would say when we ship net five, let's say the highest ios version at the time is 12..

A

We won't ship an ios 11 on ios 10 right, but that, but that also means you can only see up to ios 12, because that's the only thing we have so if we now ship.net six, maybe the highest version of ios at that point is 14.

A

and then yes, the 14 assembly set, would now tell you that this api was removed in 14. But as soon as you compile against ios 12, you will only see up to ios 12.. You can't see anything later, but you will see everything earlier right, so so that in that sense you only see backwards when you cannot see forwards in time.

A

D

That makes sense.

A

All right- um and so these are basically the the three cases we have added in removed in and obsolete it in right and then edit in we just said it's minimum, because that makes more sense.

A

Any concerns around that.

C

H

Wondering they were before added in attribute. No, so I'm just wondering how that will apply to these new attributes, for example, target platform and minimum platform to boost.

A

Yeah, so edit in is effectively minimum right, so edit inbase it tells you which.

C

A

Api was added in and that's basically what the minimum does, but it says at the minimum you have to be on ios 10.

H

It's not it's a target platform, then it just means kind. Don't need to check of our target platform like if I.

A

H

Performance just for the our runtime or something.

A

Yeah so target platform I mean we basically would just burn it in so that we have it similar to target framework right. We, we don't really use target framework much it's just recorded in the assembly. So when you look at it, you know what.

C

It was compiled.

A

For um so you should not look at target platform at all. You should only.

C

A

At minimum and then.

C

A

Moved in and obsoleted.

C

A

If we want to support the analyzer for that, but yeah right now, the only thing you need to focus on is this. Guy here.

C

Something that hasn't been said, but I think it is probably worth clarifying- is that your targ, if you don't specify a minimum os platform, then the build will automatically burn in the your target platform to to be that value right. Because if your target platform is ios 14 and you don't explicitly say I'm supporting an older os, then it's going to assume that your minimum is 14. right, so that burned in at compile time.

A

Yeah, so you should always so basically you always have this attribute present and it it will be either exactly this version or a lower version right, because if you would yeah, as you said, if you omit this line here, we would just burn in this gun.

A

All right so then attributes are covered. Then we can talk about os platform and runtime information. So one thing that has come up before which you should also talk about, is what do we do with the existing environment west version thing, but before we go there, let's first focus on these guys here. So the reason we have these ones here was for two reasons. One of them was well. We our existing os platform, so our existing environment.os version has some enum for oss, which are no longer that great.

A

So we basically don't want to use those, but the version number that is returned by it is still valid, uh but basically we wanted also to make sure that people don't really do version comparisons themselves, and basically that's why we have this api here, where you basically say are you this platform, and then we say yes, no one design that falls out of this is that we can be multiple platforms at the same time now this may sound weird, but it's actually not that weird, because, for example, we have linux and we have freebsd right.

A

So we can say: yeah freebsd is a form of linux, but it's more specific to say it's freebsd. So in that sense, if you, if you ask like your linux, yes, are you freebsd? Yes, uh and so in that way, we can also support this.

A

uh I think that earlier than you know, ipad os, maybe it's a specialized form of ios, so maybe ipad os would say. Ios is yes and ipad will also say. Yes, if you ever add it right.

A

That's why we kind of have this inverse logic where you pass in what you want to query for, and we tell you whether that's true or not, rather than we tell you who we are, because that will make it very hard for us to add refined choices over time. um In that spirit, we basically basically said. Okay, maybe we should have another api that is similar to the version checks that the windows guys came up with, which is use.

A

You ask for the version and we do the comparison for you, and so this is the same here. We basically say: here's the westbound we want to check for and then we just you can pass it up to four version numbers right. um People suggested to use the version struct here, but I think that makes it just harder to write the call and it also makes it harder to analyze.

A

So that's why I didn't do that. But basically, yes, you can just pass it up to four version numbers and then we have the inverse as well, which is the lowercase check. Why is it lower and not lower or equal to? Well, because if you want to check whether you know should am I allowed to call this removed in api, you want to pass in the version number where the api was removed in right. That's why I said okay, it makes more sense of an api like this.

A

Where you can say yeah, you can call this removed api. If it's an earlier version, then whatever version number, the api was removed in right same with obsolete it, and so that's the only reason why you want to have the inverse case by and large. I expect most people to use this. One, though, does that make sense to people.

C

Are we are we modeling freebsd as a version of linux, because it's yeah.

E

A

E

A

Well, I just gave it as an example like if it's not, then it's not but like. I think by the point.

E

It's a unix system which is posix compliant and has the posix apis available, but it doesn't have any of the linux kernel specific things: okay,.

B

E

Similarly, to mac, os is a unix-based system and generally has most of the posix apis available.

A

So then replace what I said earlier place the mix with posix. But then the point still stands right. You will be able.

C

A

Say this is a project's compliant operating system and multiple might say yes and and then you can also ask for the specific ones right.

I

uh Emo a quick comment on this. I know you said you didn't want to use the version uh type in these parameters, but it might be good at least just to have an overload that takes them just in case. Someone already has an instance of that floating around.

A

Yeah, so I thought about that. The problem with that is, if we do, that, then is your expectation that our analyzer can handle that, because that might be hard right.

C

A

Because now, if you're passing the version well, then we would have to find the place in your code where the version was constructed, which now means you have to data flow analyze your code and then find out which version numbers you actually specified.

A

C

A

C

That's that also brings up. um Maybe we should um maybe we should have the analyzer. Give you a warning if you use um variables in in these calls.

A

Yeah I mean yeah, I mean variables will be okay, so long, they're constants, because then we can still see the value.

C

A

Variables constantly yeah.

I

Well, I think michelle was saying non-constants but yeah.

A

Yeah, like basically yeah like symbols, are okay, basically, but not vegas. We.

I

A

um It's that's.

D

Oh yeah, we talked about the literal expected for uh some of the stuff in intrinsics and it seems like this would be if we had that attribute, we would put it here, but we just may put that in the platform compat analyzer of like hey, um I I don't know what it means to be. Is it am I later than version x where x was passed into this function?.

A

Yeah so one thing we should consider, though, because everything is string based now should we have an isos platform or later that just takes the compound.

D

D

Maybe I mean it: does it would? When we talked about the what the attribute should take, we did say that by accepting it as a unified string, it means you can have defined it as a const in one place and just keep referencing it and that does it would give equivalent value here it does.

D

I guess the platform compat analyzer is already going to have to parse that string to understand the breakdown so.

G

D

Doing it doing it at the call sites here and doing it when the attribute comes out, it's the same parser. So as long as we use the exact same strings, it's not a problem.

I

Well, it's not just that, but if you look at what we do in our unit tests like our unit tests literally introduce helper methods, is windows 10, rs5 or later, and we call those helper methods which would delegate to these. But if those helper methods are used to guard a call site, will things fall apart?.

A

Yes, because you have no way of saying that.

I

Right now right, but I I think I I anticipate that's actually going to be the majority use case for these apis. I don't think people are going to sprinkle these throughout their codes throughout their code basis,.

A

But then help me understand why these helper methods would be easier than uh basically a very simple version of these apis like why can't we make the call these apis as simple as your helper method,.

I

No, what I'm saying is I, if I'm trying to guard a feature that exists on, like I said, rs5 or something I'm not going to want to have these call sites all throughout my code, saying: okay, os platform, dot, windows, comma 10, comma 19485 or whatever, like I'm, I'm going to want to wrap all of that into a single helper method just called like. Can I call this api? Yes or no? Oh, as you.

A

Were just saying right in that case I mean this goes back to the string right. If we would take a simple string, you could just define that that string in your project file and you would just name the string- uh feature x, availability and you would just say this. Is you know, windows, rs5 or whatever.

I

Yes, that could work.

D

Yeah and I think that people would be very apt to write the helpers if we did these across two releases, but if the analyzer that you're hoping will help you and the requirements from that analyzer come in the same time that these apis do that's an immediate disincentive to to write the helpers and but yeah. So I think the string will help make the code be more legible and easier to reason about, and it's no more complexity on the analyzer. Given that we've already made it interpret the string from the attribute so.

A

Yeah um so now, let's talk about the controversial stuff, actually.

D

A

D

Contradict myself, it means we've pushed the complexity into the run time, because now the runtime needs to be able to split that and turn it back into the right answer.

A

To a certain extent, yes, that's that's the only concern I have of the string, but like to a certain extent. That's also true today, because somebody has to be able to answer. Are you mac os right.

D

That's easy: we in runtime information it's cross compiled and the dll knows it was os x and it just it says, return true. If you asked for os x and false for anything else, uh once we get the string that you need to turn that back into the identifiers, we understand, which means we need the string parser to ship as part of.

I

We we don't actually need to turn it back into the identifiers, because we can actually special case that within the runtime itself, for instance, if, if I'm running on windows- and I receive a version string, that literally does not begin with the characters w. I n dash, like just return false, fair enough.

I

It means that we've.

D

Pushed the complexity of the string parsing into quartet and.

A

D

Be the only cost, but it's probably worth it.

A

I mean yeah. The only thing you basically have to carry is yeah, like every slice of the build needs to know its aliases right, but you don't have to have total knowledge ever right, which is probably good enough, because it just means today you already have to say if, if mac os, true, you say well, if mac os or osx equals two right, like I mean that doesn't seem terrible.

I

Right and what I, what I was mentioning earlier is, I think the implementation is going to have a lot of if depths in it, but within any individual. If death, the actual shipping logic should be relatively simple. I.

A

I

A

Yeah, that's the whole, but now that's that's. Actually a nice segue to the controversial thing. So uh we have today an entry called osx on os platform because we already shipped this. You know three years ago. Whatever then we called it osx at that point and of course it's not called osx anymore, it's called mac os. Now I originally had the mac os field in here or property. I should say, and then I received feedback like already have was x, remove it.

A

um I I expect the or the friends uh like michaela and others who build the the other side of the house, not be super happy with that. So now the question is: are we? Are we going down this path? Are we saying no just have a mac os property here and just make it an alias for osx.

D

I mean at this point anybody who's writing new code like they did the rename long enough in the past, I would say, make add mac os and eb. Never os x. We can't remove it, but so we'd make them be functionally the same in in the runtime.

A

Yeah, that's actually a good idea.

D

But as that's essentially we're aliasing, the member.

I

And I'm also not, I don't think anyone here would be opposed if you just remove it. It's 2020.

D

uh Existing assemblies that already have it mean they can't roll forward. That's a binary. Breaking change like you can't have built net standard to you'll, build net standard, 2o and you'll crash on net 5.

I

You're you're also assuming that netstandard 2o, which came out what, like three years ago, someone's actually targeting that very particular member from a net standard 20f. But yes,.

A

I

A

I mean the problem.

I

A

Works today at one time right like we do the right thing, so the question is: why would we go out of a way to make that not work like it seems simple enough to be so to just, I think, editor browsable actually is nice compromise, because you remove the complexity most of the time and then it still works right yeah.

A

I think that's, probably nice.

A

Cool so then that was easier than I thought. If you only took an hour, that's unexpected.

B

A

Else that we haven't talked about.

B

So you um I think, somewhere in here and you talk about combining multiple platform checks. So if you do need to you know, if your code does need to check is os platform or later against multiple things. um If the yeah, I think people are still going to want to write helper methods to wrap those, so I don't know.

A

How to guard against that give me an example for that, because I think the only things I can think of is basically the example that leva had earlier, but I think a string based overload will take care of that for the most yeah.

B

These rate ranges as well right if you need to check both the min version, as well as the max version and see if you're inside a range, then they'd have code of is os platform or later and is os platform. Earlier then,.

D

I mean if we wanted to support helper methods like that, then we could do uh because so c or the latest version of the c sharp compiler for nullability has the you can put an attribute on a member that says it. It makes this field a particular field, not null, so we could have a return based attribute or just a simple attribute on a member that is like guarantees, minimum version, and then you know takes one of these platform strings. So we could.

D

We could compose things based on that if we thought that was important ranges, I think are still going to be hard because we need a upper bound and a lower bound attribute.

B

But if we do, if we go with the strings and we get rid of the ants getting passed in entirely, we could introduce a helper method for a range. I mean.

A

Basically, what you would want is kind of an assert attribute at that point right where you say um this method is asserts that you know the lower bound. Is this and the upper bound is this right?

A

I mean this certainly.

C

The wrong term is basically like.

A

It returns true, if that's the basically it's something like the uh you know, which you know false if or whatever we called it inaudibility, where we say the return value is corresponding to this condition right. um That is possible, like I, I would think like to me that's kind of refinement of the analyzer like I'm, not convinced that we need it yet.

A

So I would start with that and see how far we get.

D

Yeah because I don't, I think, if we take the strings, then we've probably made it simple enough that people don't wouldn't feel compelled to write an analyzer or not a helper method to make their code be more legible, because what you'll have is if runtime information is os platform or later you know.

D

Platformids.Rs5 right and like it, it says that right there you can read what it says. What's the benefit of you having is rs5 or later as a as a named member that took no parameters like it reduces only a few characters.

A

And it would be the example that jeff had, which would be if you combine them as a compound expression, where you say: random information is os platform uh or later and is os platform earlier than blah right. Basically, if you want to have a range check, but even then, I would argue that the range check probably reads easy enough, and it's probably in a few enough cases that it's probably fine.

A

I

Reads easy enough in english, if I'm not an english speaking software developer, I might choose to have helper methods that are in my native language.

A

Maybe, as a german, I'm not convinced, I would do this to myself, but but yeah.

B

And I don't know what it would you know if we did some sort of range-based method, then we'd have to handle the case of you pass in ios conflicting ranges like. Oh, I want ios 12 and as the minimum and less than tv os, something or other, and that starts getting crazy right.

A

Right yeah, I would, I would say, like similar to nullability, let's start with the simple cases and then, as we are basically using this thing ourselves and our customers, you will probably find some cases where the analyze is not expressive enough, and then we add more attributes to handle that yeah, because I mean.

D

Honestly, like it depending thinking of how the analyzer probably works, though I have no idea how the state flow stuff actually works, because I I skipped that in my analyzer's introduction, uh essentially it's you hit this. If and then inside that lexical scope, you push a new, uh I now have a new minimum guarantee for ios and like so.

D

If you have a thing that just slaps a bunch of attributes of like hey, if this returns true, then you can assert that the minimum os is ios, 14 or ipad, os, 9 or mac, os, 7 or and and it's less than tv, os, 97 and right, and essentially it's just pushing things into the state machine of the analyzer yeah.

A

Literally, the.

D

Same state that it would be carrying.

A

D

We could do.

A

It I can give you the the logical thing how it works, like think of the method body as a control flow graph, where you know statements but also conditions right like, and you know, a and b and c and d right.

A

This is also control flow, because b only gets executed when a was false right, so they give basically a complete control flow graph for the method and then basically, what the analyzer does it effectively has methods like you know, create state and then uh merge state right where, basically, when you have uh nodes that are joining, you basically merge the states from from from both branches, and so the state in our analyzer case is basically what is the asserted minimum version and what's this sort of maximum version, and then you know when you, when, when the state is basically flown to the through the to the graph, well you're, effectively combining these uh states right and then at a given point in time.

A

You can say well looking at this code here now based on the state. What what can I assume the minimum and the maximum to be right and that's basically what we would do? um It's not super complicated like it's it's fairly straightforward, given that there wasn't a team, now has an actual api that does the flow for us. The only thing we have to do is basically construct the the state right and override the methods.

A

It's still a fairly complicated api. But logically, it's relatively straightforward right.

D

But so it's when you get into the I've, you know I've hit a flow node and I need to push data into it. It would be go copy. The you know asserts minimum version, all those nodes into your min version state bucket and asserts maximum version or asserts less than version into your upper bound state. So like right, we.

C

D

Do it, I don't think it would be super complicated, but it means that we'd be adding a bunch of attributes right now for a thing that we don't know that anybody's necessarily going to do.

A

D

I think the first thing we will most likely.

A

Add to our analyzer is uh probably environment, os version, because there's probably a fuckton of code that does that today and so the problem with that. Is uh that basically it's not what I said earlier right like because you have not a simple method like here: you basically have a you, know.os equals or dot major is less than or whatever, and so extracting what the person actually was asking is fairly non-trivial, because there's just you know a huge tone of combinations that you could interact with right.

A

The bigger problem with runtime uh with environment os version is that forgot what the name is, but the os kind enum that we return is completely busted at this point, uh because many of the members don't make sense, so I think the best we can probably do is we can say we can extract the version number. Maybe.

A

But if the person tried to detect the operating system, then we're probably out of luck, but I don't know how you how you extract than the os at all, because I mean maybe you can say well if we know that the project was targeting dot net framework, we can assume it's windows, but uh but then pretty much. That's the end of it right as soon as the target net crap. Like I don't know what a version check by itself would mean.

D

Unfortunately, we've merged with mono, so you can't make that assertion anymore.

A

uh That's, I guess also true, um but yeah.

B

Okay, so so I think the moral of the story is we'll have so each of these two helper functions. They'll just have string params. They won't like. We won't do the major minor, build revision args at all right.

A

Oh, I would never do yeah. I would do both because I mean, technically speaking, it's for the analyzer. It's not super hard because basically.

C

A

They're both kind of the same entry point almost um okay uh and.

B

All right, that's that's fine, so we've got so you can either do a string or you can break down the version number parts, but we would have to document. We don't support helper methods around these. You have to use these these two methods directly in the guarding code right.

D

With regards to the analyzer.

B

Yeah with regard to the analyzer for runtime, we're still going to guard you, but if you want the analyzer to work, as you said before, jeremy, by shipping, these at the same time, um we'll then get that feedback. And then we just need to ask folks where the pain points are and see. If we need to add, you know, potentially add more helper functions or attributes and and in conjunction with that, enhance the logic of the flow uh determine flow logic in the analyzer.

D

B

D

Cool yeah, the runtime behavior, is it'll work. If you do helpers, it's just the. If you turn on the analyzer to help you understand when you're doing something that doesn't make any sense, that will not understand the.

E

Helpers, do we know how how complicated it's going to be to get the jit to recognize these as constant given os platform is a struct that contains an opaque string, uh and similarly, I guess for the analyzer, if someone defines their own os platform. Static. Read-Only, for example, uh is the analyzer going to be able to correctly recognize what the string constant for the os platform is no.

A

I mean same thing like basically, if you don't pass in directly os platform.blah, like I would say, that's the same thing as if you pass a variable to the version number like we don't know, because otherwise you would have to do. The problem is first of all, you would have to do data flow to find the original thing, but even data flow might not be sufficient right, because this thing might be initialized by the constructor or a different assembly, oh yeah, and then it's like.

A

Well, I don't even know who like where, where the thing was set so like I don't know how I would find out what what video it holds at one time um and so yeah. That would generally say you can't do that.

D

Yeah, so it would need to be a constant expression, whether that be a inline literal or a reference to a const.

G

D

The analyzer will just say like this is not a thing. I can reason about write code that I can reason about if you would like to use me, but you know polite.

B

So I want to make sure I understood again run time. It would work fine, but the analyzer would not be able to interpret correct.

D

Right- and I don't think it's I mean yes, performance is good to care about, but I don't think it matters if the jet can optimize this or not, because it means that you're doing complicated things. And if you want to do simple things, just say your minimum version is your minimum version or say that your target version is your minimum version and you never have any of these checks.

E

I don't think that's good, because there's things like directx metal and vulcan, which have os specific apis, which you're going to want to use on hot paths, in which case you're going to want to have these checks. So you write it once and it works.

A

Yeah so the way I would model those things is, I would I mean it depends on how you want to do this, but, like normally, I would assume you do this check way. High up.

E

Right uh for a lot of these apis, I don't think that's necessarily a good idea. It's similar to intrinsics, where you might have an algorithm, which is essentially the same, except for this one particular call you're going to want to decide.

E

Do I do blend or do I do and and not or and which one you do is going to be used in that one spot in a hot loop and you're going to want the jit or the aot compiler to go and uh drop the dead code path, essentially to make sure that it is as optimal as possible. It's not going to be this high level check with a bunch of code. You duplicate five times over.

A

I mean that's fine, I mean like what are we doing for s platform today? Do you know.

E

Right right now, it is not a jet constant and there's been complaints from people uh about it, causing perf issues in their hot pads.

A

So what so, what would we have to do like? Does it just re-attribute this thing, or does that like actually did require to like? Do I.

E

Think there would be jet work required to recognize uh os platform properties here as uh intrinsic and then track what they are. With regards to other checks to know, okay, the user's passing in os platform android, the other four parts are constant. So therefore we can emit a constant check and fold it down to a gt, true or gt false.

A

So what is the actual technical term for this? It's like it's called like constant, folding, okay, so, but but by the deck. Basically, I meant more, like what's the term, for a method that the jit nails will always return the same video in a given process.

E

Well, there's there's basically intrinsics and constants. Okay.

C

E

The jit can convert intrinsic method into a constant in some cases.

A

The other thing I understand is like they would still have to like. They know when to run the code right because they have to at least run it once right, because they don't know what the answer is right. They just know that.

E

A

Know the answer it will never change.

E

The compiler would so, for example, with hardware intrinsics when the jet starts up. We query the cpu for what do you support and we cache the information in this.

E

For this particular scenario, we would uh know what os we're running on already and then we could query what version we're running against and cache that and then, when you encountered such a check, the jet could fold against fold the values passed in against the values that it has cached and decide to to convert that call into a constant, true or false, which then allows the dead code to go away.

A

Yeah, I guess my my the questions and that's the thing I'm not entirely sure, because you would basically have to replicate the logic that the method does into the jit. Then right, because the problem is you.

C

A

Either cache all arguments and say for this argument, combination and all the answer, or you have to basically replicate this thing and says yeah. I know I'm running on on on mac os, but if somebody asks for osx, that's also true right.

E

Yep- and we have to do that for things like math.sine and round, and things like that uh anywhere, where we want to support constant folding, you have to have something that the jet can hold against.

D

But you know the for the general problem. You know I'm aware that making an artificial class hierarchy with a virtual member and then hoping for de-virtualization is not grand, but it does get you at least the the one-time wait. This was the only object that got created. I know exactly where it's going. It's sealed stop doing, vert calls and just jump to the address and it's more work. You have to do in your code, but until we can make the jet smarter it solves the problem.

A

Yeah, that's fair, I think the I think starting summer is probably good a good uh a good point. I mean I will. I will start the discussion with the team and then see how much work that is, uh but I think we should first start implementing the methods anyway to just get a sense for what it would take.

A

Sweet, so any other concerns, or is that it.

E

Are we going to support debug assert in addition to, if in the analyzer, uh so.

A

There's a separate spec for the analyzer, but yes, I had the same realization 10 minutes ago that we need to support the barcodes as well.

A

H

When we finish.

A

H

Finished this api. Sorry, um could we take a look on the analyzer issue.

F

H

Not not exactly reviewing, but I have some could have some.

A

A

I mean that's one of the questions. I asked my niche like to me the debugger. The debugger's third case. Is that really the way they should that should be handled is by the control flow engine already, because, logically, they know that if the condition is false, they should basically treat the result. This unreachable code- um and I think he said they will they're they're doing that the compiler doesn't do that, but we don't use the compiler flow analysis. We use the the flow analysis that they wrote for.

H

A

H

He had tests that debugger system.

A

Yeah, I think that's special k, debugger. Sorry. I think I think.

H

I asked him whether they.

A

Have a generic attribute for that, but he said no they're, just hardwired debuggers sword. I.

D

Mean the compiler not accepting debug assert as true is the right answer, because in the release build you don't have that check and you're just hoping, but for things like nullability analysis, it's like well, you promised in your debug, builds that you never saw no get past here so we'll run it it'll, throw like.

A

D

A

If you're wrong, you get an exception right, like yeah deciding.

D

That, like this, the state passed here doesn't exist, is not a great thing for the compiler to do with debug, assert or debug fail, or you know, like your code, is still there eip or rip is still there. You just now need to deal with that.

D

Otherwise, it's a runtime assert.

B

D

Yeah, so I think we've covered this unless we decide the helper methods are the thing that we need to tackle right now, but I I would leave them out for now with the kiss principle.

B

I'm good with that.

A

I would have used yakni but yeah same same answer. uh All right, then I guess I keep doing this.

A

I guess I can remove blocking now.

A

All right so then do you know the analyzer issue top of your head.

A

H

A

Oh, you paste it in chin, okay,.

H

I had lots of questions about versioning, but so now attribute doesn't have, I mean, doesn't have separate versions. So, let's make it a little bit easier. I guess.

A

So there's anything in particular you want to so we just go top to bottom or do you want.

H

A

H

No, the goal in non-goal is the same as your, so it's doesn't matter and well for expectation, so apis to be that attributes need to be implemented and all aps annotated.

H

I I'm not sure who's going to do that in how, but my most concern is the platform context below it.

A

A

Yeah so like when I wrote this, I tried to write it in a simple way, but apparently it's more complicated. Then then I would have written differently, but basically so what I tried to say in the spec when I said platform context, it's basically the idea that the way the analyzer logically works right. It basically looks at every method call or any any. You.

C

A

Call into your project and then it says well, if, if the api that you are calling is considered platform specific, then we basically.

C

A

To compare what the api requires with what the call side guarantees and so basically.

C

A

Is that the call side has uh different kinds where the guarantees are coming from right? One is the global context, which is the you know. Is the project itself uh specifying anything right and so the we can probably ignore this entirely, because, logically, now, this whole stuff is caught by this stuff.

A

Here right because we don't have a platform version, we have minimum os platform attribute and that is always applied to the call side right because it like at first it's at the assembly level right but like everything within that assembly, when you just walk up the hierarchy, you will eventually hit the assembly level attribute, but the call set itself- you know the method or the containing type might also have the attribute right, and so in that sense you you basically just look at that, and you say well is the call side guaranteed to be that version number.

A

Then I you know I'm fine or if it's under a guard right. These are the only two cases you have to consider effectively right this one stuff. Here you can completely ignore because it's it's flown into the project as an assembly level attribute.

H

So right now, what I have is like check, tfm and then also for that call site. The number two and the what you're talking about is that number three like checking using that api check, that.

A

H

A

H

A

This one right, that's what I'm trying to say.

H

So number two is the pretty much checking if the containing method has the attribute right, but it's not using the that runtime is os platform later earlier.

A

Correct it's aesthetic.

H

Yeah, it's just checking if it has uh contains annotation but um well. I thought the one will be like the only one case to check like easy or faster. It will be same for all entire code. You know so it's.

C

Maybe really if it's.

A

Because you basically always have to walk from the from the call side outward right, because the like just because the whole assembly is platform, specific, doesn't necessarily mean that your call side has the same guarantee right.

A

So you always have to basically say well. Is the containing method attributed no if it's containing type attributed? No, if it's containing assembly annotated and like? Basically, you basically walk this list inward to outward and then the first hit is basically telling you what the version number is and then for the most time here, you will basically walk all the way up to the assembly, and then you say: oh this only says it's 12, so I guess 12. It is.

A

Does that make sense.

H

Well, yeah, it's just.

A

It yes, so that.

H

So that's why so.

A

That's one thing we, I think, talked about with manish last time right so the way the analyzer needs to work in general. Is you basically only look at call sites where you know that the the api you are calling is platform specific? You try.

C

A

As early as possible, like if the api that you're calling isn't platform, specific, there's no point in walking right, yes, and so that that already cuts down 90 of the call sites. And then you only do the walk for the for the things that perform specific. But there's no really a way to um to to to shortcut that and then the only other shortcut you have is the the next line here right. So the so the flow analysis yeah. You try to shortcut that as well. You're, basically saying, and we only do the flow analysis.

A

If the method contains any platform specific.

C

A

Right and then and then you do the fallback and say yep. Okay, now, let's actually walk the call graph, I should say the control flow graph um and so yeah so this so this check is really expensive.

A

C

A

Not super expensive, because this one, you can also cache right because you can, you can.

C

A

Well, if I already walked the time, I don't have to walk past the type again right.

H

I I have already one and two kind of implemented and but didn't went to now about to start on the tree number three and.

H

Link, okay, then so you mean, if tfm is not always specific.

H

And it doesn't if, if gfm has always always specified- and it has observation of the os, then it should just ignore it. Whatever.

A

So like, in your case this one here.

H

A

Falls out because the thing is you basically just look for minimum os platform attribute right. So if the project itself is net five, uh we will not burn in the the or the minimum wise platform attribute right. So that means the way you detect that the assembly is neutral is by basically just saying well, do you have a minimalist.

C

Platform attribute.

A

You don't have to look.

C

H

Yeah for the first section, but if tfm is platform specific, we should check that. If that platform is much then we could. We don't need to check that number. Two and three that case if it matches and the platform and version is much.

A

You can generally assume that the version number can't be lower. Yes, so like, if the, if the project itself, if if the project's minimum version number is already enough to call the api, then yes, you don't have to check two and three.

D

Yeah is it this analyzer's job to do the warning for if it does see a minimum higher than the or minimum os version higher than the target frameworks, embedded, os version and and or if a method is going lower than the assembly lower or the class lower bound.

A

So that was long sentence. Are you asking whether it's legal to have a minimum version that is higher than the what's in the tfm.

D

Right so if the tfm says ios 1012. or says ios 12. and then the minimum os version says ios 14.

A

D

um So is it this analyzer's job to report that.

A

I would say no.

D

So that's so you so garbage and garbage out on that. One.

A

D

A

Produce a warning for that but like that, but that should come from ms build right.

D

I mean the ms build wouldn't know if you've uh injected the assembly and assembly info.cs manually like it. If you didn't use the properties, it can't warn, but.

A

Fair enough, but like yeah.

D

The right so then there's the state of the assembly says minimum os is ios 14 and then some class says the minimum os is ios 11. is. Is it this analyzer's job to warn on that.

A

So should the analyzer warn.

D

If, if the class is lowering the minimum from the assembly.

A

Minimum wireless platform- I think this one yes and then I guess in that case you might as well handle the assembly level one as well right, yeah.

D

Right so it's just it's a question of like you've said it's an invalid state, and so is it.

C

D

Analyzer supposed to report on it or is at every level in this analyzer, is it garbage and garbage.

G

A

Yes, we should probably handle that case.

D

Because that would just be the again when figuring out for this type, the first time you have to resolve it and it's like. Oh it has the attribute. Well now, let's compare it to the assembly attribute, hey, that's an inverted relationship, produce a warning and maybe the whole analyzer shuts down, because who cares you're in a broken state at this point, but um but the yeah just figuring out what what the error conditions are here since so many manual attributes have to be applied.

B

A

Yeah I'll record that in the spec for the analyzer like that, should be.

D

A different diagnostic than hey you're, calling a method that you can't call. Yes, hey your your attributes are in a nonsense state. Please please address.

D

But because the phrase was used here of like well, that doesn't make sense and that's an invalid state. It's like well is that an assertion or a verified fact so.

A

Yes, okay. Does that make sense to you boy? Do you understand the flow now.

H

Well, uh I I didn't exactly understand that jeremy's point but but for others I'm good.

D

That's okay: jeremy's points are usually so esoteric. Even he doesn't understand.

H

I mean I understand that if it's not very strange numbers found within the versions or always, then we should report that.

A

H

D

Right, just yeah emo had suggested that a if an assembly, a class and a method all have the attribute they have to either or they have to be getting more and more restrictive. Instead of you're allowed to get more permissive. And then I felt like asking the question of: is the analyzer checking that or is the analyzer.

H

D

Believing that to be true.

H

Well, that was actually my question in my list of questions, but if it's in such case.

B

And did I understand right there that the recommendation is if we do find that we're in a bad state, because the values conflict with one another, then the analyzer would essentially turn itself off and just report one diagnostic that we can't proceed.

A

Yeah, so the way so the way analyzer works is that you basically can decide what you're walking, and so I would say you should probably have in the registration where we say what we want to walk. We should also walk the declared symbols in the um in the project, so that means you would basically walk. You know every every declared type method and so on once and you basically just compare the minimum os platform version if it's present, with the target platform version and.

C

A

You find anyone that is higher, you report errors for all of them and so that that basically means you're reporting the error once and then. Yes, of course, the analysis that you will know for these methods will be incorrect.

D

A

Sort of a pre-validation.

D

G

D

It reported anything in the pre-validate, then it doesn't move on to the full validate.

A

Yeah that one, I'm not sure how you tackle these two together, but yeah yeah. I.

D

Mean you can still run it. I guess the the pre-validate's telling you anything that I say past this point might be garbage expected. Semi-Colon.

A

Yeah, but that's I mean usually you're trying to avoid the report. Cascading errors right because then you're right I mean I guess. If this is an error, the other ones are warnings. It will probably bubble to the top by severity.

A

um But yes, we should we should. Basically I mean logically, we should probably not analyze methods where we've reported an error for the attribute that was applied to it or it's containing.

I

I

You had, um I think you had started talking uh of a minute or so ago, but cut out.

H

I

Okay, just checking thanks.

H

I had lots of questions about the versioning because the pair was attributed was required so and always platform check has.

H

Not required all the versions, you know that is earlier than or whatever it has overloads, not using all the all the numbers. But but I guess now, I'm good, because we are not requiring all the versions for the attribute.

A

So is the question of what how you compare them or.

H

Yeah, if, for example, tfm doesn't have any like, has always specific, uh like ios whatever but doesn't have the versioning, then right now it will be like zero zero zero for my in my calculation because the versions are required, but.

A

So so, where do you mean the version number submitted? You mean in the project file it's submitted or.

H

Not, for example, in tfm in the project settings.

E

H

If tfm like net 5 and dash ios without version number, then what version it should be.

A

Yeah, so that's.

H

A

So that's so I haven't called this out here, but it's called in the tfm spec. So basically the idea is that is, I guess you don't have an example here. So if you omit the version number in the project file uh that like doing build, we know what version number this is. So the idea is that if you say net 5 dash ios with no version number, the sdk knows well net 5 ships, initially with ios 10. So then the attribute that we generate will have 10 in it.

A

So that's why, generally speaking, you shouldn't look at the tfm. You should just look at the generated attribute um and the attribute will always have a version number there's, no such thing as a version less tfm. In that sense, it's just it's just convenience that the person had didn't have to specify it in the project file.

A

But if you ask for it.

H

It's always going to attribute you mean that the trip is generated from build. Yes,.

A

So basically, the assembly level attribute- that is the minimum os platform attribute that is generated out of the tfm, and the target platform attribute that we have. Those will always have version numbers.

H

What what's the.

H

Target platform menu version, but that one was empty.

A

Yeah so like, if.

H

You it wasn't provided.

A

So if you say something like this right, if you say net 5 ios and no version number, we know during build that when net 5 shipped the version of ios we supported was 12..

A

So basically, if you omit the version number, it will always mean the same version number and like at build time. You will know what that version number is because it's hardwired into the sdk and so the like. Even if you omit the version number, if the version number that we bundled with net 5 was ios, 12 target platform will still say: ios 12 and then, if you didn't specify this property here, then we just set it to this one.

A

So you will always have a minimum platform version and it's either exactly this or a lower version number. But there's always a version number in that. In your case, if you just look at these attributes, there's always going to be a version number. The project.

F

A

Might not have it, but that's.

F

That's doesn't matter.

D

These attributes aren't always present, though, right, like uh the.

H

Platform neutral.

D

Assembly does not have these attributes.

A

Well, if you say net five, then yes, so that's what I'm saying so, if you're, if your platform agnostic, then yes, the way you find out is because these attributes are not present.

D

Right, but once they once these attributes exist, they will have an os and a version. Yes.

A

They're illegal, without it.

H

So I just can expect these attributes will always be exist. Yes,.

A

H

Mean at least target platform.

A

Well, if well, if they are present, they will have a version number if they're not present. It means this. The the the assembly is uh platform neutral, which means you shouldn't be able to call any platform specific apis.

A

So everything you call should be a warning.

D

Everything with a os.

C

A

With a platform.

D

Guard is a warning, not everything's a warning.

A

String, yes, everything that is not marked otherwise either by a platform guide over attribute, is no warning.

D

Do we, you know who is related or who's responsible for painting registry and such and are we doing that in this release.

A

So my goal is so once this attribute, so today we approved this one here right so like my next task is doing exactly that, like going over the apis that we know. So let me start differently about. We have this guy here, github.com platform compatibility, which was our first analyzer, and this one basically has a database effectively right, which is a glorified way to say. There's a csv file and the csv file tells us what is windows specific, um and so I will.

A

I will use that as an input to say where we should sprinkle some attributes, and then I will bring that to api review probably next week. If I get it right and it's probably.

E

A

A list of things that we should put the attribute on.

E

Are we going to be attributing winforms in.

A

I was thinking about that. um We will probably not do that, because the only way you can reference them is by targeting the platform specific uh tfm already. So the only reason why the attributes would be useful is for version information, but given that both wpf and winforms are supported, all the way back to win7 and bin7 is the minimum that we support in general. uh It's just overkill at this point.

E

What about mono since mono sports win forms and registry at a minimum and those were cross-plat.

A

So for well, if you use mono, then none of this makes any sense right, because if you're using mono, you use the dot in favorite reference assemblies anyway, so the attribution doesn't buy you anything.

A

Okay, so like this is only when you compile for n5 right. um Otherwise, you won't see the attributes to begin with.

D

And then the mono mono versus core clr doesn't matter at that point because it's the same reference assemblies.

A

Right um so, but I mean so, I asked this uh the winform stream at some point because they said, like you, keep adding these new apis. How many of them are actually supported on all platforms, that.net core runs on and so far everything they added is supported everywhere. So, but eventually they may have a property that only works when you're on wind10 or up or something right. And then we may actually put the attribute on those guys as well.

D

I feel like right now: they're still excited to get caught up with vista.

A

Yeah, I think that's true, um but I think registry is a good example right. I would probably just mark all of registry as win seven right.

A

That makes probably the most sense, as opposed to put an antibiotic in every single type right, yep.

D

And the fact that all of our accol stuff for io and and the like are in a separate assembly means we have one one place to slap all that too.

A

Yeah there's a few cases where we couldn't right, but, like that's actually the nice thing with these attributes, you can apply them at any level.

D

But okay, so that is it, so it is a goal for five that the shared runtime is properly annotated. With this.

F

um I wouldn't go that far, but yes, there's.

D

A hope for five that the shared run time is properly ended. Yeah. Okay, let me let me write this.

F

Down, let me write this down if.

D

You prefer hope instead of goal, we can, we can soften the the statement.

A

um We should make sure that all.

D

If it's not, that's, I'm just um see also the discussion of. Do we want to have the high level review of every nullable annotation that has been added in the last year. uh How much time do we need to spend on painting assemblies with stuff that we shipped 20 years ago.

C

Right, it's very much this this whole thing very much came out of like this is what ios and android do already so. Can we make the experience better there and then a logical progression is okay. If things in in in corefx have the same problems or then it makes sense to apply there, but that's not so much the primary goal, more more logical progression.

D

And I assume for the concept formerly known as xamarin, that this is already being taken care of for uh where it's exposing the platform apis right.

C

D

C

The annotations exist um just it's not using these exact, um these exact attributes. Of course, they have their own attributes right. Man.

A

Yeah, I think to me it's important that we get the broad strokes right right. It would be pretty dumb if registry wouldn't be annotated right. That seems like a wmi wouldn't be annotated right or a system.directory services wouldn't be annotated, because we know that they're all windows specific right um well.

D

We just made half of directory services work on non-windows platforms,.

A

Okay, so then, maybe no longer but like like that for a very long time was windows only right, because we just walked into windows. um If we don't have a for implementation, that's great yep.

A

Sweet so then anything do we need to do for this one here, then, do we need to approve this guy.

D

Did you have any further questions in the analyzer for you.

H

I don't think so because it's based on the previous attributes, so it's need to be updated too. I guess doesn't it.

D

Yeah uh in here emo have you. I assume you've specced out what it means for.

D

Saying ios 12 versus ios 12, comma zero, like are you? Are we zero filling with the the overloads.

A

I haven't called it out, but yes I mean that's, that's the only sensible, behavior right, because system.version doesn't do that and it compares them differently, which I think is dumb, because I don't think anybody can reason about that like because the the whole contract of these methods is you basically ask: are you running on this platform or later version of it right so, like everything you didn't specify is implicitly zero.

D

Right so ios 13, which is about halfway in the screen right now. That will be true for 13 rtm and 13.1 and 14 and uh etc, but not 12.9, which is it sounds very stupid to say this out loud. But, as you said, system.version has different feelings on does 13.0.0.

D

How does that compare to 13 or 13.0, and so I'm just making sure we've addressed that.

A

Yeah we do, we do sensible comparisons here, we don't do crazy comparisons.

A

um Yeah, I should probably call this out in this next summer.

D

And do we know of any? Do we have any system? That's using a four component version with a api set.

A

No, the maximum, I think, was three.

D

A

D

We're building.

A

D

Out because we know that that's as far as things go and- and we don't want to get caught later with the thing we couldn't express.

A

Yeah, like I mean vertical numbers, are always four components right so, like you might as well. Okay, I mean, I sincerely hope nobody ever does that, but I think to michaela's point earlier right. I do think we probably never use it for the for the os version right, but we may actually end up doing it for the sdk, because if, if you have you know, if a platform uses three digits to indicate its support for apis well, then maybe we need to rev our sdk one more step right.

A

So that means you may have to actually have a fourth digit for the sdk yeah like.

D

I don't know that apple introduced apis in it, but when it was os x, I think it was you know. 10.14.1 was the first update to 10.14 and if they.

C

D

New api, then we would have needed three characters and then is there a just asking a high level question? Is there a notion that someone might want to use this, for uh I know that there was a bug in 10.14.0 and I don't run unless you have 10.14.1 or higher, or is that a non-goal for this.

A

No, that's the same thing that we do for targeting packs right. We do not allow you to pre-rack bug fixes I mean you can of course use the ap, the the apis. We have to check for that but like, and we can't really stop you from doing that. Right, I mean you can totally annotate your assembly with. I require the minimum version number 10.3.4.2 and you will get the right behavior out of the system, but uh you wouldn't be able to express that as tfm's right so like.

D

I'm just asking all the related questions I can think of while we're looking at the subject.

A

H

One last question: oh sorry,.

C

Sorry go ahead, oh yeah! If you do know that it is specifically an os bug, then I guess it would make sense to use that, but you certainly shouldn't use it for um for framework bugs or binding bugs.

D

Right, but we we would expect- or we would not expect that we would ever do that in any of our metadata and we would not recommend someone do it with their metadata, but they could.

C

Yeah not unless we know that some api is like literally unusable, but what's that happening I don't know.

A

I mean I would expect us to do quirking in the implementation using these apis but yeah. I don't think you would ever.

E

A

It as an attribute somewhere sure.

H

I have a question for the attribute versioning, so now they don't have separate version and it will be attached to the string. So that means like not all the version parts are not exist. I'm thinking just if it says like I was 13. Then if there is another annotation found like suppressing annotation or something found like a ios 13.1 or whatever, then I I would just ignore the missing part or make it zero.

B

Jeremy is that what you were explaining with the would you call it spreading zero or something zero.

D

Yeah, so I think the answer is, if it, if something says, minimum os version, ios, 1, 3 and that and then a close quote, that that is the same as if they said 13.0.0.0.

D

uh Logically, whether or not we normalize those states but as far as the comparison is concerned, 13 and 13.0.0.0 are the same thing.

H

Okay, just making sure, because I thought now we can ignore it, but okay.

A

Yeah, I mean basically the way to think about it. You bring all version numbers into a four-digit space right and then, if anything, that.

H

A

Specified you use zero and then you compare.

H

That just makes a little bit strange, so I thought now we can ignore that because just concentrate on the the number we have already have.

A

I'm not sure what you mean by ignore I mean that's, basically, the equivalent of.

H

I mean if, if the numbers are missing, then for example, I have one attribute 13 ios 13 attribute in the calling method, and but that method is suppressed with the um 13.1 then for evaluating. If I need to warn it or not, I just ignore the missing part like just check for that numbers. 13 like first major and ignore the remaining part.

D

Well! No because if the caller says he's just ios 13, that would be 13.0 and if he's calling a 13.1, that would be a warning right.

H

Okay and nothing much.

D

Changed all right, sweet! Congratulations! Emo! We solved it in one.

A

We solved it in one pass: yeah. um Well: okay, I'll update the analyzer spank with the things we talked about, including the attributes that we know approved, and I will call out some other details.

A

Sweet, then that was that.

A

Cool then uh I wish you guys a great weekend. Everybody will see you later today. I see you later today and then enjoy.

H

A

Enjoy the rest, bye, bye.

H