KEYNOTE Simply Scala Martin Odersky

[@rockthejvm]

Humbled to be mentioned in the talk! Will continue our work to make Scala accessible

[@edmaphis9805]

4:25

[@rafaelkss2009]

Yo Daniel and Scala guys, girls and all, plz don't dumb down the language, we got enough bad languages around, but yes, without compromising the beautiful design, by all means do it! Good job anyway.

[@i-am-the-slime]

Please do dumb it down. Remove the shitty subtyping and variance. Get proper type inference, make an Editor work with Scala 3.

[@AI-xi4jk]

No matter if I’m able to program Scala daily or not I always cherish all the things it taught me and try to apply those ideas at work. Thanks Martin and team!

[@i6g7f]

Very interesting talk! Thanks a bunch!

[@yawaramin4771]

Hasn't the async SIP been withdrawn? Surprised to hear that it's a compiler phase now and doing transformations into a state machine. There's no mention of it in the docs.

[@i6g7f]

1:00:30 Scala 3 and IDEA works ok, yet sometime manual correction on imports needed, but not a big issue.

[@i-am-the-slime]

It fucking stops working every 30 minutes. It's horrible.

[@Hugobros3]

not sure the grammar size metric is that useful ... most people would agree c++ is a vastly more complex language than c#, for reasons that are harder to quantify (general insanity of the compounding language features and warts)

[@souluss]

Inlined ZIO? My initial reaction is that it will pollute entry-level libraries and the effort will contradict the entire first part of the talk, i.e. it will make basic code more difficult to understand, with compiler bugging newcomers about capabilities and whatnots. Now if something is ZIO, it doesn't try to hide its ambitions in controlling resources and effects, while people learning Scala can choose non-monadic libraries to work with. Nonetheless, it might push better programming standards to broader public, so the resulting ergonomy will be critical in weighing these trade-offs.

[@misaacsable]

Who's the kid at 5:00 ?

[@kevalan1042]

Couldn't the compiler easily quantify the times due macro expansion and explicit expansion?

[@i6g7f]

it does quantity complexity which is proportional to time? see 18:55 .... use -Vprofile Parameter

[@Kwpolska]

I'm an ex-Scala developer, and I think this keynote is wrong in so many ways. Scala is not simple, and Scala 3 introduces many new things that make it less simple, starting with the new syntax. There are now two syntaxes, and while indentation-based syntax can work right (as seen in Python), the Scala implementation of it seemed broken and confusing when I tried it (with IntelliJ). Many new Scala 3 features are there to help type astronauts write even more clever code, which is the opposite of simple. Scala 3 also helps the clever code crew with even more macro stuff, which is cool and all until you end up at a buggy magical macro while debugging something. Scala jobs do exist, but they are very rare compared to established languages (Java, JS/TS, C#, Python, C++). This keynote also seems to be contradicting itself, since it starts with making Scala simpler, reducing complexity, using less functional stuff, and then introduces a new type-astronaut feature, and also re-introduces checked exceptions (which Java has shown are pointless, since in most cases, the exception will just bubble up to a top-level exception handler). This presentation claims that C#'s grammar is 4x larger than Scala's. I read through C#’s grammar, and some of those differences are caused by the grammar defining more of the language - for example, C#’s grammar explicitly names the "int" type 3 times, whereas Scala considers it just another class. Similarly, operators like / or

[@i6g7f]

The Scala 3 intendation syntax works nicely,shorter code, fewer curlys, with IDEA e.g. no problems so far

[@j-r-hill]

I think, in true Scala style, it's possible that both of you are right.

[@jmhimara]

I also think the "size of grammar" might not be the best metric for measuring complexity. Like he said, F# is larger than scala, but very few would argue that it is more complex.

[@voltydequa845]

A gnawing resorting to vague critic. Though I have more experience with gnawers (or cheap trolls, under the concept dictionary of old irc days) than the others here. Some thought on the fly, for eventual tempted to take you seriously - the 'clever style' is a side-effect of all rich and higher languages (as Haskell, for example) - 'smart' people are less then the rest, so it is normal that programmers in smart languages are less than the rest - rich languages come with a price that somebody can express concepts difficult to understand by others - comparing with Kotlin is like comparing USA with Swaziland

[@i-am-the-slime]

It's completely ridiculous to deny reality by claiming Scala is a simple language. I don't understand what can be gained by acting that way. Nobody wants to do OOP in Scala yet all the inheritance Bullshit is still there. No enums that work still. Newtypes are fucked up. Editor support is worse than 6 years ago. You have all the JVM Bullshit like wasting memory, extremely slow starts, jars and binary incompatibility, etc.

[@CuriousCauliflowerX]

Since when is the number of grammar files a measure of simplicity? This shows that haskel is one of the simplest languages, but the language has a ton of ecosystem divergence with incompatible language plugins, so it's very complicated in practice. And so is scala, there's a reason people are leaving it in droves.

[@voltydequa845]

Curious. I was thinking the same, though I do not have all that experience with Scala. The simple grammars, upon which can be built rich languages, can result in much higher complexity. In Italian we have two distinct words - 'lingua' and 'linguaggio', where lingua is language, and linguaggio is (a mean of) communicating by means of common (in the sense of shared) symbols (concepts, and the like). So 'linguaggio' is built upon the 'lingua' (language as a set of words and grammatical rules), but its semantic meaning depends on shared meaning (out of understanding) of its constructs. So the 'shared ways of expressing' help as much as with spoken languages. Haskell for example seems extremely elegant, but you get lost in composition and in decomposition (understanding) when dealing with problems with higher complexities. So the only solution is discipline where constructs perceived as weird by a certain percentage of coders get dropped / discouraged. As for discouraging I share his point about SBT - the fact that it is not easy to describe it (teach it) implies that there's conceptually something far from optimal.

[@jlhidalgo]

Martin Odersky saying that Scala is a "clean and simple language" would be funny if it wasn't tragic (for Scala that is, which is not that much of a tragedy after all, and less and less every day). Scala is so painfully over-designed and over-complicated that it has never been stable enough, and it's taken an extremely risky, non-backwards compatible, almost decade long redesign of the language just to solve some of the most obvious issues and throw away many things that were plain wrong. Think about macros in Scala, for example... after three complete re-designs it's still a source of innumerable issues and doubtfully usable by the average programmer (maybe the fourth time will be the good one) And "no boilerplate"?? Yeah... just look at ADTs or pattern matching in Haskell or Rust or any other language that has them versus the same in Scala. Or wonder why almost everybody that uses Spark (pretty much the most relevant system implemented mostly in Scala) uses it from Python. Or why many projects are ditching Scala altogether. No, the blame is not on the users: not in the "traditional FP crowd", not in the tool developers, not in the library developers, and not in the casual users. The blame is on the language itself... and probably looking at this video you can see pretty much where (or "on whom") much of the blame lies. The really funny thing is that unlike back when Scala was designed, nowadays we do know that a complex language might succeed, if that complexity is justified because it solves some real problem. It has been shown by Rust, for example. Complex is not necessarily bad, if properly justified. Being in denial and lying about complexity, on the other hand... pretty bad, any time, indeed. The title of this keynote should be something like "Bad excuses, instead of a much needed apology, show the way for further failure". Or maybe "Turning 'embarrassingly bad' into 'barely acceptable' thanks to lots of (your) effort and pain"

[@paulfunigga]

You are wrong saying that most people use spark from python, at least here, in Russia, very few people do. I've worked at multiple companies and nobody used spark from python.

[@spesterwecial]

@@paulfuniggaHe’s wrong about a lot of things, in addition to being personally disrespectful toward someone who has graciously contributed a great deal more to industry and PL research than negative, bitter comments on the Internet.

[@sosoga1977]

Wow wow wow, somebody has no appreciation for beauty. Scala to me is the most beautiful language out there

[@j-r-hill]

It must be a really thankless existence to be a semi-popular language designer

[@captainbodyshot2839]

Rust did not succeed by any objective metric