3 ms·
Regarding C#: > The "billion dollar mistake" is important to me, and while C# has non-nullability sugar in its typesystem (i.e. with ? after a number of types)
by int_19h 4y ago
Regarding C#:
> The "billion dollar mistake" is important to me, and while C# has non-nullability sugar in its typesystem (i.e. with ? after a number of types), the type system wasn't as rigorous as I was maybe hoping.
I'm genuinely curious if you have any examples? Nullability checks may be bolted on, but once you enable them, they should consistently prevent you from dealing with any null values that you haven't explicitly allowed. And other than that, the only hole in the type system that I can think of is array covariance, which was unfortunately common at the time (Java had it also) as a way to skimp on generics, but which doesn't occur often today because using generic collections is much more common.
> At one point I had a bug because I did a stopWatch.Elapsed / 1000 by accident instead of stopWatch.ElapsedTicks / 1000. The former is a TimeSpan struct instead of a long like ElapsedTicks, so intuitively it feels like I shouldn't be able to divide it, though it did a best effort and did something to it, though I'm not quite sure what.
This particular one doesn't have anything to do with the type system per se, it's just the way TimeSpan itself works. I'm not sure why "intuitively it feels like I shouldn't be able to divide it", since there are fairly obvious definitions of arithmetic operations on spans and numbers - if T is 10 seconds, then surely T*2 is 20 seconds, and T/2 is 5 seconds? Which is exactly what TimeSpan does by overloading the corresponding operators:
https://learn.microsoft.com/en-us/dotnet/api/system.timespan#operators https://learn.microsoft.com/en-us/dotnet/api/system.timespan...
Note that the type of (TimeSpan/double) is still TimeSpan, so the type system is still enforcing proper use - it wouldn't have let you assign it to an int or a double. But it looks like you were just printing it, which is legal for any type:
Console.WriteLine($"loaded stop_times.txt in {watch.ElapsedMilliseconds} ms");
- Someone 4y ago> I'm genuinely curious if you have any examples? Nullability checks may be bolted on, but once you enable them, they should consistently prevent you from dealing with any null values that you haven't explicitly allowed. I’m not the one you asked, but there’s a difference between you no longer having to deal with null checks and your program no longer having to deal with null checks. The CLR will still do the null checks and fail your program fast when needed. Other languages will require you to properly handle them (or at least, make it obvious where you chose to bluntly abort the program when they occur) I also don’t think C# will prevent you from forgetting to do a if null check in cases where you expect values to sometimes be null.
- jolux 4y ago> I also don’t think C# will prevent you from forgetting to do a if null check in cases where you expect values to sometimes be null. It should throw a warning in situations where a non-nullable value is not clearly non-null when it’s dereferenced. So you won’t get a warning in the body of a method declaration with a non-billable parameter, for example, but you will get a warning if you attempt to pass null into it.
- int_19h 4y agoYou're describing C# as it was before nullability tracking. For several years now, it does have a mode in which every reference that can be null must be explicitly checked to be non-null first before you can use it, very similar to Kotlin. https://learn.microsoft.com/en-us/dotnet/csharp/nullable-references#null-state-analysis https://learn.microsoft.com/en-us/dotnet/csharp/nullable-ref... So yes, "will require you to properly handle them" is exactly what I meant.
- Someone 4y agoFTA, emphasis added: “Nullable reference types refers to a group of features enabled in a nullable aware context that _minimize_ the likelihood that your code causes the runtime to throw System.NullReferenceException.” That approximates it, and likely gives you most of the benefits, but it isn’t the same as strict enforcement of necessary null checks. There will be cases where the programmer can prove a value isn’t null, but the compiler can’t, and thus, the programmer can choose to ignore the warning. That’s similar to how Java tries to prove that a variable is initialized when being read. (https://docs.oracle.com/javase/specs/jls/se9/html/jls-16.html https://docs.oracle.com/javase/specs/jls/se9/html/jls-16.htm...). Java makes the safe choice, though. It refuses to compile such programs, thus guaranteeing that every local variable and blank final field will be initialized before first use.
- int_19h 4y agoThat's exactly why I asked for specific examples of when nullable enforcement does not catch a potential null reference at compile time. I can't think of any such case so long as all the code has it enabled (if not, it's like safe Rust calling into unsafe). And if you ignore the warnings, that's a deliberate opt-out; why even bother with nullability checks then?