 um hopefully you're having a better day than i'm having because i got two videos in the pipeline and the oh boy do they make me want to die um they're taking a lot of effort you'll see them hopefully in a few days but oh anyways um with the last in this installment uh an adam grant brought up a adam ward adam ward brought up a possible oversight in the language and he was definitely on to something um there was a little extra step that needed to be done but he definitely found another oversight so let's go over this real quick and then i'll cover the details afterwards uh we have a subtype of integer called predicated integer and it has a static predicate that specifically says its values can only be three five seven and eleven so if you try to assign it any value that isn't one of those you will get an exemption now we have a record type which contains a field of that predicated integer there's nothing else in here so essentially it's just the predicated integer and then we have a variable r of that record type that we just use its default initialization entirely um saying this suppresses an error message that you would normally get about how you're reading a value that hasn't been assigned even though it's been initialized uh that's sort of a safety measure and it is actually a great thing that they do that that is something i think it gets very right that other languages don't um and then we just access that value now you would expect given the predicate rules that it should be one of those values or that you should at least get some kind of error message here and um well let's build this run it and you can see that we got a zero which is definitely not correct and importantly we never got an error or warning about any of this i say this is a clear oversight because if we try to do that same thing without the record wrapping it up uh i don't know if it's going to complain in this instance because oh no it does uh so you can see that it's saying that it's never read and also never assigned and that's normally what you would get um this specifically shows off the issue with the resolution rules um not resolution rules but but now where was what what what section of the arm was this in i'm drawing a blank it doesn't particularly matter what it's called because it's what happens why this is allowed to happen um basically it's never actually checked against that predicate except when you're assigning to it the initialization doesn't ever factor that in and i mean typically speaking you're not just working with values of a single type you're usually using some kind of structure whether that's a record or a protected object or a task object you're probably using some type of collected data and you clearly have to be very careful in these instances about using the others is default clause because it just doesn't take that into consideration feeling good about those code contracts have a particular video planned for or for a particular particular topic planned for the next in this series i don't know i've got a few other leads i need to track down and implement um you know i i want to make sure that these actually happen and as you can see i'm also trying to collect them in a repo um hopefully i've been remembering to add that link in the video descriptions but if not it's at a dash exploits you can easily find it on my page anyways um yeah until the next one have a good one you know what i mean