C# is Microsoft Research's 20-year-long con to turn Java programmers into OCaml programmers so slowly that they don't notice.
I think it's broader than C# -> F# though. Java also has closures and higher-order functions, and in many debates on this forum it seems like OOP proponents aren't aware that these features are grafts from functional programming. OOP programmers also seem to have (finally) come around to the consensus that composition is preferable to inheritance.
So if there is a long con, I think it is about turning OOP programmers into ML or functional programmers. :p
class Foo(b: Bar) : Bar by bThe delegation is better than inheritance because you don't get all the methods from the base class if you don't need them.
At my company, we have banned it, because if you add a method to Bar the method is automatically added to Foo which makes the delegation as fragile as the inheritance.
Delegation does not remove the need for interfaces.
Except that Smalltalk -for which the term "object oriented" was invented - had them.
Just look at plumbing with init, data records and with. That is what a case class with val properties in Scala gives.
But congratulations to the team on shipping v9.
Thankfully that problem doesn't exist with C# /s
For a mid-sized web service (tens of thousands of LOC), a clean compile might take ~30-40 seconds, but you rarely do those. Incremental compiles take more like single-digit seconds, and for most projects you can have a solid “compile on save” type setup that makes it pretty unnoticeable. And sbt itself, which used to be very slow to startup (sometimes 10-20 seconds), now starts up in a couple seconds.
It’s not lightning fast like Go, but it’s way faster than it used to be. Not much of a pain point anymore unless you’re dealing with truly huge projects.
It isn't. Pretty much every release (including C# 9.0) adds some features that make your code more concise.