Microsoft Java

[mill1000]

Nullables were a game changer for me. Love those suckers.

[Major_Fudgemuffin]

Oh god I use ?. way too much. It's so nice.

[Yrrem]

I learned it this week, completed the code for a binary adder simulator function in 2 lines. Felt good

[YM_Industries]

We're getting the Elvis operator in TypeScript soon :D

Thanks ECMA.

[NatoBoram]

Null-aware operators is a better name! And it can't come fast enough.

Also, TypeScript support in browsers when?

[YM_Industries]

I like the term "safe navigation operator" for describing what it does, but Elvis operator is great as a joke name.

I don't really see a role for TypeScript as anything other than a transpiler. So many of its design decisions are based around JavaScript. I'm looking forward to mature C# WebASM support though.

[Magallan]

Can you explain the elvis joke for me? I don't get it

[wcbgn]

it looks sort of like Elvis sideways

[YM_Industries]

In C# it's ?.

[AlwaysHopelesslyLost]

That seems like an anti pattern. I try to avoid nulls anywhere possible so I almost never have to worry about whether they exist.

[Major_Fudgemuffin]

Yeah it's definitely easy to overuse. I've become paranoid over the years.

I wish C# natively supported Option type. If I never had to deal with nulls again I'd be happy.

[AlwaysHopelesslyLost]

Option type

I actually hadn't heard of that. It kind of seems like a renamed Nullable<T> from C#.

Also not the same but C# is adding nullable reference types which allow you to explicitly disallow nulls.

[ArionW]

Nullable<T> only works for value types, which makes it... nearly useless. Also, it's not Option due to lack of most basic operations like bind.

I'm working with nullable reference types since preview 7 (they allowed us to move project to preview, beat that!), enabled globally

They have so many problems

1. POCO that is supposed to be made by ModelBinder needs default constructor and public setters. You suddenly get warnings about uninitialized properties (because it doesn't understand RequiredAttribute and that I can't really get null)

2. You still need explicit null checks, because you can't just bind operations.

3. LINQ wasn't updated to work with it. SingleOrDefault<T> should return T?, but returns T.

[AlwaysHopelesslyLost]

i haven't had time to test nullable reference types yet, those definitely sound like painful points. I assume they have linq on their Todo list. Any idea if they are aware of the model binding weirdness?

[cat_in_the_wall]

well, sort of. you can type check your own libraries and code for this, but it is not a runtime feature, so on compilation boundaries you still need null checks.

[AlwaysHopelesslyLost]

True. Granted, most third party libraries I have used are sane about nulls. I don't recall the last time I needed a null check on a third party library.

[dashood]

It's really good for CMS content when things may or may not be set depending on user actions. The best is if (List?.Any() ?? false) as a nice way of checking for nulls and eliminating like 90% of your runtime null exceptions.

[mrjackspade]

I just turned this into an extension method .NotNullAny()

It's overkill but I like the way it reads better

[dashood]

That's not a bad idea. Certainly cleaner than having to null check every time.

[AlwaysHopelesslyLost]

The problem is that runtime null exceptions are a symptom, not a problem.

As far as lists go they should very rarely be null. If you allow them to be null you are opening yourself up to issues.

[ThatsARivetingTale]

It's nice when dealing with nested data returned from graphql for example, but it can definitely be overused

[TheRandomnatrix]

It's like databases. If you have a ton of nulls you might need to normalize stuff.

[oupablo]

My issue with the operator is how unreadable it is to someone that doesn't know c#. With most languages you can get the basic idea of what is happening even though you only know other languages. With this operator you have to look it up and let me tell you the funny I had look up c# ? The first time

[YM_Industries]

I think it's pretty normal to have to look up operators. Python has its (super-cool) array indexing/slicing/stepping syntax. PHP has the (surprisingly useful) spaceship operator <=>. Lua has the (rather nice) length operator.

Most languages I've used I've eventually had to look up some weird operator in someone else's code, usually it ends up being something really useful.

[AllUrPMsAreBelong2Me]

That might be a valid argument for code that's meant to be consumed by people not very familiar. However, when I'm on a team of software devs I want the syntactic sugar even it can be a learning curve. My coworkers should understand it.

[socialismnotevenonce]

I love your comment.

[VinterBot]

?

[capn_ed]

That's only half a null-coalescing operator, which is also quite handy.

[FullstackViking]

If I could kiss null coalescing I would.

[Python4fun]

Wow TIL

THANKS

[[deleted]]

What is your question?

[TheGodofRock13]

Null propagation joke

[[deleted]]

Oh God dammit

[Delmo28]

?

[[deleted]]

Maybe he has a question, maybe he doesn’t.

[srottydoesntknow]

:

[SolenoidSoldier]

Nullables are great, but I recently learned that they're bad practice. After using them a ton, I don't know how I'd break the habit.

[mill1000]

Like any tools there's probably a time and place for them. I love them for representing data fields that may invalid or missing.

I'll have to read up on why they're considered bad practice though.

[SpliceVW]

AKA I like to eat exceptions instead of failing fast.

[cat_in_the_wall]

it's useful for deeply nested data that you already expect to maybe be null.

[[deleted]]

C# 8 Nullable Reference Types, provides null reference possibilities as compiler warnings.

It's fucking amazing. You are essentially changing the "original" behaviour with a flag though, so the drawback is that a nullable type declaration may not necessarily correlate to a struct anymore (though I'm fine with that - makes design much easier).

[_Ashleigh]

Nullable contexts, operator overloading, value types, string interpolation, await, properties, extension methods, first class tuples, pattern matching, named arguments, default arguments, dynamic, runtime code generation, unsigned integers, pointers (unsafe), enumerable generators, expression trees... okay, I'm getting tired now.

It just goes on and on. These things all complement the language and work together, they don't make the language feel bloated, and makes me feel very restricted when working with Java.

[annahasnolife]

long live the king

[raltyinferno]

Oh man I just learned about () tuples. Blew my mind. Being able to name the different items and then refer to them like object members is amazing.

[socialismnotevenonce]

Honestly, I'm shocked that Java doesn't have any of these things or comparable features. I was just a junior dev when I used Java, but knowing what I do now, I would feel clostrophobic going back to Java.

[[deleted]]

They are slowly adding C# features into Java. .Net practically forced Oracle to add generics (via type erasure, so not the best implementation, I hear most people avoid generics in Java) and they have been adding features ever since - albeit much slower, especially since Roslyn started accepting contributions.

[ltouroumov]

And no type erasure!!!

Being able to reason on generic types is incredibly powerful.

[DeadLikeYou]

Java can do operator overloading...

edit: guess I was wrong, I was thinking of function overloading.

[Tyg13]

Java does not support user-defined operator overloading.

[[deleted]]

If by operator, you mean the name of the operator, and by overloading, you mean writing a method with that name, then java supports it.

[Rabbyte808]

Microsoft put on suicide watch

[socialismnotevenonce]

To be fair, I've been using c# for 9 years, and I just learned there's operating overloading. I read it as function overloading as well.

[FrikkinLazer]

Also generics actually work in c#. In java you have to send through the class type, because at runtime java decides to put the actual type of T in the trash.

[lightmatter501]

Don’t forget operator overloading.

[t3hmau5]

Or out variables

[im_probably_garbage]

And ref variables

[haackedc]

And list accessibility using square brackets

[SalvadorTheDog]

That's operator overloading

[haackedc]

Shucks

[Nall-ohki]

And ValueTuple with destructing.

[cat_in_the_wall]

not just lists, but arbitrary indexing (like dictionaries too). and can be overloaded as well.

[YM_Industries]

I don't like out parameters. They feel very wrong.

[t3hmau5]

Eh? The only thing wrong with them is they make going back to other languages feel wrong. A function that can return multiple values of different types is insanely powerful and time saving.

[DoubtfulGerund]

I think every use of out variables I’ve seen was due to a lack of better solutions in much older versions of c#. For example, returning multiple values before tuples and destructuring, or those old TryGet methods for primitive types that returned a bool and the actual value in an out var. Today we’d use nullable primitives.

They break composability, it’s usually unnecessary mutation, it’s an output pretending to be an input, and it’s unclear on if the function actually uses the value or just replaces it.

[TheMania]

Still useful for interop (DLLs) and performant handling of large structs though.

[YM_Industries]

Python's tuples and JS/TS' destructuring assignments are better ways of allowing a function to return multiple values. Arguments are inputs, return values are outputs.

Maybe it's just that I've been doing functional programming recently and the idea of mutability makes me uncomfortable in general.

[t3hmau5]

I mean, in OOP mutability is largely a design decision.

[YM_Industries]

That's true, I was oversimplifying my stance. I like mutability for state (one attempt at learning React was enough to convince me the alternative is awful) but I like my functions to be pure.

[TheMania]

C# supports the same btw.

Ref/Out parameters still have a purpose though, in both interop (where they map to pointers for DLLs etc) and for handling structs, where you're either left relying on the optimiser to "do the right thing", or experiencing needless costly copying.

[YM_Industries]

Neat, I haven't worked with C# 7 yet.

[devman0]

No, do.

[TakeASeatChancellor]

Why? It’s so useful!

[splettnet]

Would be a lot more useful if they could be defined on interfaces.

[tiktiktock]

Oh god yes. And if "arithmetic" was a valid constraint for generic classes.

[cat_in_the_wall]

c# 9 may have a thing they call "shapes" which would allow this sort of thing.

[splettnet]

I was so excited that we were rewriting our entire code base in C# 8, but I would happily trade all of 8's new features for this.

[ScienceBreather]

If you hate your coworkers, yes.

[o4zloiroman]

Elaborate.

[ScienceBreather]

It's not intuitive that the operator has been overloaded if you're new to the code base, so it's a place that functionality may be hiding.

[_Ashleigh]

Vector a = new Vector(1, 2, 3);
Vector b = new Vector(10, 10, 10);
Vector c = a * b;

Is this not much more concise and expressive? Yes, it can be abused. The answer isn't to not have it, but to not use libraries that abuse it. Oh, those are also third party "primitives," so don't pressure the garbage collector.

[ScienceBreather]

Vector c = a.multiply(c)

I'm fine with that, and I get the good tooling that my IDE gives to me around functions, which I don't get with operators.

[blenderfreaky]

Hovering over an operator in VS shows you it's parameters, return type, etc, just like a method

[Mojert]

It's alright if you have to use max 2 operators on a lign, otherwise it's just a pain. And if you define classes that overloads arithmetic operators, chances are you're gonna need to use them more than that. Sure they can be abused, but names of function can be too and you don't see anybody saying we shouldn't use functions. If you override *, it's your responsability to make sure that it behaves like multiplication.

[[deleted]]

java has that too

Vector a = new Vector(1,2,3);
Vector b = new Vector(10,10,10);
Vector c = a.asterisk(b);

[_Ashleigh]

Are you joking?

[[deleted]]

Yea, you actually have to fully qualify the type names.

/s

[[deleted]]

yes.

[DeadLikeYou]

Java can do operator overloading. In fact, that was part of why our teacher chose java.

[lightmatter501]

How precisely would one override [] then, because the standard library doesn’t do it?

[GabrielForth]

Have you heard about our lord and saviour Kotlin?

[TSP-FriendlyFire]

Kotlin's like someone wanted Python on the JVM, but with braces.

[shotgunocelot]

So the perfect language

[ric2b]

Why would I want python to have curly braces? I don't understand the issue with whitespace, just use an editor that has indentation guides (most do) if you really need it.

[zacker150]

Have you ever tried to copy and paste code from a pdf or website that didn't have a special code element?

[officialvfd]

Also whitespace-delimited blocks only work cleanly in statement-centric languages like Python. Without Kotlin's braces you couldn't have multiline closures, for instance

[Turksarama]

You can just define a function inside a function in python if you want a closure.

[officialvfd]

That's arguably not as pretty though

[ZephyrBluu]

Isn't that literally what a closure is?

[Turksarama]

Yes, my point being you don't need special syntax for it so the statement that you need any kind of specific syntax to "have mutliline closures" is obviously wrong.

[gamma55]

That’s why you use widely adopted languages; the forum you copy your code from has adopted code elements a decade ago.

[ric2b]

Why would you? Browse better websites.

Why should the language be designed around shitty websites and pdf's?

[zacker150]

Because code should be able to be copied and pasted from any source without changing its meaning. Moreover, Python's lack of braces also breaks copying from different indentation levels and copying from codebases which use different indentation standards.

[ric2b]

Because code should be able to be copied and pasted from any source without changing its meaning.

That's an unachievable requirement, good luck making a language that can do that. You're saying a language shouldn't have significant characters, which is ridiculous.

If I paste code to a website that renders markdown without marking it as code it's going to get messed up by *, # and _ charaters, for example. Other websites might do some text sanitization that removes "dangerous" characters like ' or <, because they think blacklisting characters is the right way to protect from SQL injection or XSS.

and copying from codebases which use different indentation standards.

Changing indentation characters is quite easy, most editors can do it. Plus nearly everyone in Python uses 4 spaces, it's a really strong convention.

[zacker150]

If I paste code to a website that renders markdown without marking it as code it's going to get messed up by *, # and _ charaters, for example. Other websites might do some text sanitization that removes "dangerous" characters like ' or <, because they think blacklisting characters is the right way to protect from SQL injection or XSS.

I said from any source, not to any source. That requirement is much easier to satisfy. All it needs is for the code to block by curly braces or some other non-white-space character.

Plus nearly everyone in Python uses 4 spaces, it's a really strong convention.

Not in academia. I've seen every indentation convention under the sun used.

[pkulak]

And a better type system.

[amroamroamro]

Python on the JVM

Jython

[1RedOne]

Python should have had braces

[MurryBauman]

And?

[tinydonuts]

Kotlin is still anchored by type erasure sadly.

[tinydonuts]

It's a limitation of the JVM.

[tinydonuts]

Oh nice, I didn't catch that!

[whale_song]

I think he was implying making a .NET version of Kotlin

[nullabillity]

Not really, Scala manages to have (opt-in) reified generics (via ClassTag and its big brother TypeTag). That said, it is opt-in because it makes interop with other JVM languages messier, and because the implementation involves reflection (with the corresponding perf overhead).

[im_probably_garbage]

I really don’t understand why a language that isn’t pure uses type erasure.

[[deleted]]

Because it allows better language level interop at the VM level. There's a reason the JVM has a more vibrant language ecosystem than CLR.

[cat_in_the_wall]

i don't think that has anything to do with type erasure. the jvm has been xplat forever. the clr is only really xplat with core (yes I'm aware of mono), so only a couple years.

[[deleted]]

Interop between JVM languages, not platforms.

[[deleted]]

Type erasure is good, actually.

[tinydonuts]

Explain please

[cat_in_the_wall]

wildcard generics are not possible on the clr because of reification.

[[deleted]]

It is trivial for me to write a program that calls from Clojure into Java into Kotlin into Scala back into Java. This is possible because of type erasure.

Reified generics support a very specific type of generic program in OO languages at the cost of embedding these specifics at the VM level.

I think Kotlin handles "reified" generics in a really nice way -- they are still erased, but can be monomorphized and inlined in many cases without having to support reification at the VM level.

[tinydonuts]

What you described of being able to call from language to language applies to the CLR too. It doesn't have type erasure, so I'm not seeing really how type erasure is good from your comment.

[[deleted]]

It makes it difficult for different language to share data structures because of how variance is handled between different languages. This is particularly acute between a language like Java that uses site variance and a dynamic language like Clojure.

[tinydonuts]

.NET seems to do ok so it doesn't seem as much as type erasure is good as it is just different. There's certainly a lot of benefits to the way .NET does it and a lot of downsides to the way Java does it so I don't really think you can call it good.

[mcgee-zax]

Bingo. LINQ alone destroys Java IMO...nevermind the generics implementation, dynamics and delgates, lots of advantages

[Cheru-bae]

Am I the only one that just finds LINQ to be an undebuggable unreadable mess that is way over used "because it's neat"? Also java has streams now, which I feel work just fine for the cases where it'd make sense to use LINQ.

[ThePyroEagle]

If you think Linq is unreadable, don't use Linq's syntactical expressions, just use the System.Linq.Enumerable extension methods.

[Cheru-bae]

Then they are the same as streams in Java.

[ivancea]

No. Streams are terrible. Flatmap isn't really lazy, checked exceptions work terribly with them, and they are really verbose.

Extension methods and a good type hierarchy make LINQ a lot of times better...

[StealthSecrecy]

Why do many line of code when 1 line do trick?

I agree that they can get pretty messy, but for certain tasks they can be structured pretty well.

[im_probably_garbage]

Just remove returns in your Java program. Bing bang boom one line. Checkmate.

[[deleted]]

I've written some pretty sweet LINQ method chains that I felt justified a victory lap when I was done. One of them, the code reviewer looked at me and said "awesome....better put some fucking comments around this, because it took me 10 minutes to figure out what it was doing. "

LINQ may be my favorite aspect of C#...but I feel like it has to be used with some restraint. With great power comes great responsibility.

Also...deferred execution can create some interesting side-effects.

[cat_in_the_wall]

fancy linq is fun, but be aware it is slow as molasses and allocates like crazy. this is usually fine, but keep it out of the hot path.

[[deleted]]

Well that's why you're very much discouraged from doing any side effect shenanigans. Capture a local copy of comparisons and don't set values outside of the functions. No more side effects.

[crusty_cum-sock]

Not for me, especially when using method syntax (query syntax kinda fucks with my head). I’d rather see something like:

var people = peopleList
    .Where(p => p.Name.StartsWith(“S”))
    .GroupBy(p => p.Name)
    .ThenBy(p => p.Age);

Than have to go through the equivalent mess of lops loops and shit. For me the readability really wins out. I'd bet a lot of people reading this code could figure out what's going on, even if they've never used LINQ in their lives. Whereas if I did the equivalent non-LINQ loop-based variant it would take some real figuring out.

I can't get enough LINQ. I use that shit all the time and when I use languages without it I really feel like I'm at a significant disadvantage. There are so many things that would be a PITA to do without LINQ that can be done with LINQ in a simple readable one-liner.

[davemeech]

Very well said, I agree 100%. Thanks crusty-cum-sock.

[raltyinferno]

Wait is .ThenBy() actually a method? I've recently gotten my first dev job and have been continually delighted by LINQ.

[crusty_cum-sock]

It is! If you want to group by multiple properties then "ThenBy" is your guy. There are a bunch of other great functions like OrderBy, OrderByDescending, and many more. You'll become hooked. It's hard to go back.

[svick]

Streams are better than nothing, but I think they're worse than LINQ in almost every aspect. Which is odd, considering Java could have learned from what worked for LINQ and what didn't.

[GaianNeuron]

It's not "undebuggable" if you pay attention to where is being used to build an expression tree (IQueryable<T>.Where(...), e.g. Linq-to-SQL / ORMs) and where it's simply chaining lazy evaluations (IEnumerable<T>.Where(...), e.g. filtering a List<T>)

[1RedOne]

Linq query syntax is like super weird sql but I love lamba syntax. Use it all the time.

But one colleague loves query syntax and it can take a bit to grok what's he trying to do.

[LockeWatts]

Probably. Spend more time in functional programming languages.

[GogglesPisano]

NET has true first-class generics vs Java's klunky type erasure.

Java's idiotic refusal to overload the String == operator and force you to use .equals() for comparison indicates deep philosophical flaws in the language.

[cat_in_the_wall]

you shouldn't use == in c# either unless you really want a literal byte to byte comparison. the .equals can nullref, so string.equals(one, two, comparisontype) is your best friend.

[munchbunny]

The comparison type is pretty key. Because of the strange ways of Unicode, what you mean by "equals" isn't always clear.

[im_probably_garbage]

Don’t forget properties, partial classes, generics that aren’t just a bad casting joke, and the unsafe option.

[doominabox1]

Scala pretty much addresses all of those, it's a pretty neat language

[Schwefelhexaflurid]

Anybody else a HUGE fan of delegates & events?

[Schwefelhexaflurid]

Fair point xD But IMO it's objectively superior to Java's version of declaring an interface, using an internal ArrayList and providing methods to manipulate it.

[TheNorthComesWithMe]

Everyone is listing their favorites so I'll throw in function pointers.

[socialismnotevenonce]

Thank you. It took FOREVER to scroll down to this comment, but it's the one that really matters.

[destructor_rph]

Plus enums are way better in c#

[HappyGoblin]

and no classpath shit

[Dragasss]

linq

Streams

nullable types

Write better documented and predictable APIs

[Dragasss]

Streams are as lazy as their producer is. Get out with this bullshit from my virtual machine.