Really cool presentation

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)

Congrats for explaining a complex topic in simple terms

19:05 10 MB should easily fit in L3 cache of modern CPUs.

the visualized example on invariant, covariant, contravariant are so helpful. i have been struggling for years. not any more

Cant wait to have it in scala 3 :)

739 living legend

I really appreciate you and the team making this template!

Many thanks Pawel, this is very promising work and superbly presented. I hope you have been able to advance things towards the mainstream since this was posted.

Amazing presentation. Thanks to the presenter.

Please please please build a proper support for Scala on Eclipse

In my opinion, kotlin's with(scope) semantic are more clear than scala3 's using(given) , but sometime life is hard to choose between miserable and concise

Tooling, version compatibility

Nice presentation.

Hi Matt, excited and inspired by the upcoming type-system capabilities you're working on, eg for typed linear algebra structures. Your work absolutely is and will be useful in industrial and applied Scala. Expressive types are often the most cost-effective way to prevent bugs and resist bitrot. Yet there are still a lot of program- and data- properties that remain cumbersome to express in types.

I just typed "scala-cli" at my Linux command prompt, it installed JVM 17, and then it started up! I'm not easily impressed, but I'm impressed. Very cool!

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.

Thank you

Is the Scala 3 type inference/checker as good as that of typescript?

Nothing has zero inhabitants - check! Unit has one - check! Bool has two - check! Durian has six? - 😵‍💫

Great video! This talk really help me become more understandable in Scala Type System.

is the live charts code on github?

Great talk, so helpful!:) didn't know anything about "transparent inlines", it's cooll! 14:15 would be really cool if one could see your mouse pointer, more easy to follow the many examples.

Very interesting talk! Thanks a bunch!

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!

Thanks Sebastien, I learned an awful lot by following along from home, you covered so much ground..

Who's the kid at 5:00 ?

scala js is useless

Super intro aux ADT , merci !

Great talk, thanks!

As far as I know implicits will be kept, and given/using is an additional option in 3. Implicits will be deprecated in future? Don't think so...

Very helpful talk, thanks!

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

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 <= appear three times each, but Scala considers them to be methods of Int or other types - so they live in the class library, not in the grammar. C# does have a few features that complicate the syntax (like LINQ), but I would say that C# is simpler than Scala, because it allows less "magic" - there are no custom operators, no macros, no higher-kinded types stuff, and just the right amount of functional programming. The Scala ecosystem is also complex. For example, ScalaTest supports 8 different testing styles, which is 7 too many. In the HTTP world, there's http4s, which has a lot of type astronautery, and which really wants you to know HttpRoutes[F] is a Kleisli category, which is a great way to discourage your average programmers. Error handling can also be very inconsistent, with some libraries throwing exceptions, and others preferring Either. All in all, I consider Scala an over-complicated language that tries to do too much at once. Kotlin does a much better job at being "a better Java", and people actually use it (thanks to Google adopting it for Android). Many other languages have adopted Scala's good parts without taking too much.

This is why almost nobody wants to use scala lol

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.

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"

Awesome!

Looks like just by restricting imports everything can be fixed in Scala 2

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.

Scala-cli is amazing. It makes toying around with scala so delightfull.

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

Just discovered this talk and really enjoyed it. Very well done, Nicolas!

Thanks for making Scala CLI

Concepts here are explained very clearly - great talk!

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

Great initiative. Will it support multimodule setup with an option to build each module separately (and build all by default)?

Iskra is really cool! thanks for this presentation

That's great stuff. "Don't over-complicate it!" Using a URL to load & compile something directly from the net is very nifty.