[Parazitull]

This seems similar to the joke where after Brexit, the Germans are angry that english is still the official EU language and they change the english language until it sounds a lot like german.

In a few years, C# 20.0 will have only one release note: Changed the name from C# to F#

[corysama]

C# is Microsoft Research's 20-year-long con to turn Java programmers into OCaml programmers so slowly that they don't notice.

[throwaway894345]

This made me chuckle.

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

[discreteevent]

> these features are grafts from functional programming

Except that Smalltalk -for which the term "object oriented" was invented - had them.

https://www.infoq.com/presentations/functional-pros-cons/

[thoraway1010]

yeah for composition - I ALWAYS liked it much better!

[snuxoll]

Some languages even have syntax sugar for it built-in, coughKotlincough

    class Foo(b: Bar) : Bar by b

[_old_dude_]

This is the most controversial feature of Kotlin.

The 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.

[snuxoll]

> 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.

[throwaway894345]

Go has a similar feature, and while I don't know that I would say it's especially controversial or frowned upon, it's good form to only use it sparingly if at all. I still wouldn't say that it is anywhere near as fragile as inheritance; however--I think inheritance's fragility comes from its polymorphism (not sure about Kotlin, but in Go, the wrapper class/struct can't be passed into a function that expects the component's type).

[rad_gruchalski]

With Kotlin and Scala in existence, that ain’t going to happen. C# is as verbose as it was years ago. After years of Scala collections, eithers, options, why would anybody consider C#.

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.

[couchcombinator]

Because Scala takes mind-boggingly long to compile. Because Scala has so many features that anything has at least 3 different ways to implement it. Because it’s very easy to write unreadable code in scala, not so much in C#. Because Scala uses JVM, while C# has access to .NET (yes this is an advantage for many developers).

[whycombagator]

> Because Scala has so many features that anything has at least 3 different ways to implement it.

Thankfully that problem doesn't exist with C# /s

[yashap]

What are the last Scala/sbt versions you’ve used? Scala compilation times (and sbt startup times) have improved dramatically over time, it’s reasonably fast now. In the past 3 years, the Scala compiler has gotten literally twice as fast. I don’t have hard numbers for sbt, but it feels like it has improved by much more than that.

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.

[The_rationalist]

All your points except the last one do not apply to Kotlin

[bulldoa]

is kotlin slow to compile

[snuxoll]

It's certainly slower than javac (which is pretty freaking fast - maybe not in comparison to go, but it's no slouch), but it certainly mops the floor with scalac.

[svick]

> C# is as verbose as it was years ago.

It isn't. Pretty much every release (including C# 9.0) adds some features that make your code more concise.