Scala 3 is sorta a new language, bringing a lot of improvements to the type system: <a href="https:&#x2F;&#x2F;docs.scala-lang.org&#x2F;scala3&#x2F;new-in-scala3.html" rel="nofollow">https:&#x2F;&#x2F;docs.scala-lang.org&#x2F;scala3&#x2F;new-in-scala3.html</a>It also looks like it has some improvements for dealing with `null` from Java code. (When I last used it I rarely had to deal with null (mostly dealt with Nil, None, Nothing, and Unit) but I guess NPEs are still possible and the new system can help catch them.)

If you&#x27;re going to &quot;refresh&quot; a codebase you probably want it to be on the current version of things. Old dependencies rot, like it or not. I don&#x27;t think there&#x27;s any timeframe for Scala 2 EOL yet, but new development is happening in 3.

Why not though the upgrade process from 2.13 to 3 is pretty smooth. And you get all the new language features. I can think of a few that I actually like. I’ll just mention enums because it’s a good example.

&gt; I was refreshing one of our services. Part of this process was to migrate codebase from Scala 2.13 to Scala 3.My first question was: why?

I am not a scala fan and do not care for it, but I upvote for the thorough thought process, breakdown, and debugging of the problem. This is how technical blogs should be written. AI aint got shit on this.

Do you mean the ‘register’ keyword?

&gt; There&#x27;s an important behavioral difference between Scala 2 and 3: in 2, @inline was merely a suggestion to the compiler, whereas in 3, the compiler unconditionally applies the inline keyword. Consequently, directly replacing @inline with inline when migrating from 2 to 3 is a mistake.This reminds me of a similar lesson C&#x2F;C++ compilers had to learn with the &quot;register&quot; keyword. Early versions treated the keyword as a mandate. As compiler optimizers became more refined, &quot;register&quot; was first a recommendation and then ultimately ignored.The C++ inline keyword is treated similarly as well, with different metrics used of course.EDIT:Corrected reference to early C&#x2F;C++ keyword from &quot;auto&quot; to &quot;register&quot;.

This is one example why being a guest language isn&#x27;t optimal.They should have made use of JVM bytecodes that allow to optimize lambdas away and make JIT aware of them, via invokedynamic and MethodHandle optimizations.Naturally they cannot rely on them being there, because Kotlin also needs to target ART, JS runtimes, WebAssembly and its own native version.

The killer is specifically the inlining of macros -- which Kotlin lacks.And not all macros, but just the ones which expand to massive expressionsThink template expressions in C++ or proc macros in Rust

Kotlin heavily uses the inline keyword basically everywhere, to get rid of lamdba overhead for functions like map. Basically every stdlib and 3rd part library function that takes a lamdba is inlined.In general it&#x27;s a performance benefit and I never heard of performance problems like this. I wonder if combined with Scala&#x27;s infamous macro system and libraries like quicklens it can generate huge expressions which create this problem.

In Scala 3, the inline keyword is part of the macro system.When inline is used on a parameter, it instructs the compiler to inline the expression at the call site. If the expression is substantial, this creates considerable work for the JIT compiler.Requesting inlining at the compiler level (as opposed to letting the JIT handle it) is risky unless you can guarantee that a later compiler phase will simplify the inlined code.There&#x27;s an important behavioral difference between Scala 2 and 3: in 2, @inline was merely a suggestion to the compiler, whereas in 3, the compiler unconditionally applies the inline keyword. Consequently, directly replacing @inline with inline when migrating from 2 to 3 is a mistake.

&gt;It&#x27;s sad but I generally agree. Scala was in my view pretty well positioned for an up and coming language ~2010-15I used Scala for a bit around that period. My main recollection of it is getting Java compiler errors because Scala constructs were being implemented with deeply nested inner classes and the generated symbol names were too long.

It&#x27;s sad but I generally agree. Scala was in my view pretty well positioned for an up and coming language ~2010-15. Not only did the scala 3 rewrite fail to address many of the most common pain points -- compile times and tooling immediately come to mind -- the rewrite took many years and completely stalled the momentum of the project. I have to wonder at this point who is actually starting a new project in scala in 2025.It&#x27;s really a shame because in many ways I do think it is a better language than anything else that is widely used in industry but it seems the world has moved on.

&gt; it&#x27;s a language made by academics for academics to play with language design. It was a little weird it blew up in industry for a while.Yep. They have always been pretty honest about this.I think that it blew up in industry because it really was ahead of its time. Type systems were pretty uncool before Scala. It proved that you could get OO and FP in a single type system.Actually, a big part of reason for doing Scala 3 was rebasing the language on a more rigorous basis for unifying OO and FP. They felt that for all their other big ideas, it was time to rethink the fundamentals.

The simplicity of closure is certainly a main part of its appeal. I’ve never done OOP in it, but I don’t think I want to. I have a lot of respect for it though.

I tried getting into Scala several times and kept going back to Clojure. Unless you are into type system minigames Clojure has many of the things Scala advertises but without the dumptruck of Scala overhead and complexity. Another commenter briefly touched on this but it&#x27;s a language made by academics for academics to play with language design. It was a little weird it blew up in industry for a while.

I think it’s nice to be able to use it. But like pretty much everything in scala, it’s a huge smorgasbord of things from which you can choose. I personally don’t use that syntax, but it’s cool that I can and sometimes I do just for fun.

It was absolutely amazing how stubborn and ridiculous the whole bracket-less syntax change was handled. It was basically a dictatorial decision that they pretended to be a community decision. It was just pushed and tons of people voiced their disapproval. In the end it was &quot;so bad so sad you can always reenable brackets&quot;.They did it to try to appeal to Pythonists.. turns out that wasn&#x27;t why Pythonists didn&#x27;t use scala in the first place.

Scala has deep roots in the Ivory Towers of Academia, its not shocking they think they know better than their users what the problems with the language are and didn&#x27;t do any kind of real product management to figure out the actual problems before embarking on a rebuild.

You capture the root issue quite well.Now every tool has to adapt to Scala 3. And you guess it? It will take time. Even IntelliJ still doesn&#x27;t correctly highlight syntax on some parts that also exist in Scala 2. And this has been years after Scala 3 was launched. It&#x27;s mind-boggling.They could have improved upon Scala 2 and incrementally add more capabilities. It&#x27;s obvious they don&#x27;t care about Scala&#x27;s industry success. They care mostly about the academic success. Nothing wrong with that, but that should be made very clear.In Scala, they have a huge debate with zealots arguing against, for example, early return; they would describe how bad it will be blah blah blah e.g. <a href="https:&#x2F;&#x2F;tpolecat.github.io&#x2F;2014&#x2F;05&#x2F;09&#x2F;return.html" rel="nofollow">https:&#x2F;&#x2F;tpolecat.github.io&#x2F;2014&#x2F;05&#x2F;09&#x2F;return.html</a>, meanwhile Kotlin supports early return with absolutely no issue.

And I wish you read the article, you&#x27;re comments are completely off topic.

&gt; The problem with Scala 2 is that the type inference part of the compiler is still broken. Nobody worked on that. Instead they changed the language in ways that don&#x27;t address complaints.Huh? Type inference is much more consistent and well-specified in 3. In 2 it was ad-hoc so and impossible to fix anything for one codebase without breaking another. There are plenty of legitimate complaints to be had about Scala 3, but this is absolutely not one of them.

The problem with Scala 3 is that nobody asked for it. The problem with Scala 2 is that the type inference part of the compiler is still broken. Nobody worked on that. Instead they changed the language in ways that don&#x27;t address complaints. Completely ignore the market and deliver a product nobody wants. That&#x27;s what happened here.PS Perhaps they should make an actual unit test suite for their compiler. Instead they have a couple of dozen tests and have to guess if their compiler PR will break things.

&gt; After upgrading the library, performance and CPU characteristics on Scala 3 became indistinguishable from Scala 2.13.We had a similar experience moving Ruby 2-&gt;3, which has a ton of performance improvements. It was in fact faster in many ways but we had issues with RAM spiking in production where it didn&#x27;t in the past. It turned out simply upgrading a couple old dependencies (gems) to latest versions fixed most of the issues as people spotted similar issues as OP.It&#x27;s never good enough just to get it running with old code&#x2F;dependencies, always lots of small things that can turn into bigger issues. You&#x27;ll always be upgrading the system, not just the language.

&gt; Keeping updated libraries is a good practiceFirst, the &quot;good practice&quot; argument is just an attempt to shut down the discussion. God wanted it so.Second, I rather keep my dependencies outdated. New features, new bugs. Why update, unless there&#x27;s a specific reason to do so? By upgrading, you&#x27;re opening yourself up to:- Accidental new bugs that didn&#x27;t have the time to be spotted yet.- Subtly different runtime characteristics (see the original post).- Maintainer going rogue or the dependency getting hijacked and introducing security issues, unless you audit the full code whenever upgrading (which you don&#x27;t).

It would have been a transitive dependency based on the comments about the library being &quot;transparent&quot; and the author unaware it was even used.Pinning specific versions of transitive deps is fairly common in large JVM projects due to either security reasons or ABI compatibility or bugs

I&#x27;m confused as well, because he wrote&gt; I did it as usual - updating dependenciesbut later&gt; After upgrading the library, performance and CPU characteristics on Scala 3 became indistinguishable from Scala 2.13.So... he didn&#x27;t upgrade everything at first? Which IMO makes sense, generally you&#x27;d want to upgrade as little as possible with small steps. He just got unlucky.

&gt; Checking the bug mentioned, it was fixed in 2022.I was considerably less impressed by the reporting when I finally found out the culprit.Sure it was “Scala 3” … but not really.It was an interaction of factors and I don’t think it would take away from the story to acknowledge that up front.

&gt; So, I’m wondering how one would upgrade to scala 3, while keeping old version of libraries?The normal way.&gt; Keeping updated libraries is a good practiceSo is changing one thing at a time, especially when it&#x27;s a major change like a language version upgrade.

If your Maven&#x2F;Gradle&#x2F;SBT build specifies a version constraint for a third party lib, updating your Scala or Kotlin version doesn&#x27;t affect this(For scala-specific libs, there is a bit more nuance, because lib versions contain scala version + lib version, e.g. foolib:2.12_1.0.2 where 2.12 = scala version)

&gt; After upgrading the library, performance and CPU characteristics on Scala 3 became indistinguishable from Scala 2.13.Checking the bug mentioned, it was fixed in 2022.So, I’m wondering how one would upgrade to scala 3, while keeping old version of libraries?Keeping updated libraries is a good practice (even mandatory if you get audits like PCI-DSS).That part puzzled me more than the rest.

I agree for measuring latency differences you want similar setups. However, by running two versions of the app concurrently on the same machine they both get impacted more or less the same by noisy neighbours. Moreover, by inspecting the flamegraph you can, manually, see these large shifts of time allocation quickly. For automatic comparison you can of course use the raw data.In addition you can look at total cpu seconds used, memory allocation on kernel level, and specifically for the jvm at the GC metrics and allocation rate. If these numbers change significantly then you know you need to have a look.We do run this benchmark comparison in most nightly builds and find regressions this way.

Benchmarking requires a bit of different setup than the rest of the testing, especially if you want down to the ms timings.We have continous benchmarking of one of our tools, it&#x27;s written in C++, and to get &quot;same&quot; results everytime we launch it on the same machine. This is far from ideal, but otherwise there be either noisy neighbours, pesky host (if it&#x27;s vm), etc. etc.One idea that we thought was what if we can run the same test on the same machine several times, and check older&#x2F;newer code (or ideally through switches), and this could work for some codepaths, but not for really continous checkins.Just wondering what folks do. I can assume what, but there is always something hidden, not well known.

For production systems I use flight recordings (jfrs). To analyze I use java mission control.For OOME problems I use a heap dump and eclipse memory analysis tool.For microbenchmarks, I use JMH. But I tend to try and avoid doing those.

I use jmh for micro benchmarks on any code we know is sensitive and to highlight performance differences between different implementations. (Usually keep them around but not run on CI as an archive of what we tried.)Then we do benchmarking of the whole Java app in the container running async-profiler into pyroscope. We created a test harness for this that spins up and mocks any dependencies based on api subscription data and contracts and simulates performance.This whole mechanism is generalised and only requires teams that create individual apps to work with contract driven testing for the test harness to function.
During and after a benchmark we also verify whether other non functionals still work as required, i.e. whether tracing is still linked to the right requests etc. This works for almost any language that we use.

jmh is what I&#x27;ve always used for small benchmarks.

What are folks using for perf testing on JVM these days?

For me the main takeaway of this is that you want to have automated performance tests in place combined with insights into flamegraphs by default. And especially for these kind of major language upgrade changes.

&gt; My understanding is that Java added a lot of functional programmingThis is true, but needs more context. Java 8 added Stream API, which (at this time) was a fantastic breath of fresh air. However, the whole thing felt overengineered at many points, aka - it made complex things possible (collector chaining is admittedly cool, parallel streams are useful for quick-and-dirty data processing), but simple everyday things cumbersome. I cannot emphasize how tiring it was to have to write this useless bolierplate<pre><code> customers.stream().map(c -&gt; c.getName()).collect(Collectors.joining(&quot;, &quot;))
</code></pre>
for 1000th time, knowing that<pre><code> customers.map(c -&gt; c.getName()).join(&quot;, &quot;)
</code></pre>
is what users need 99.99999% of the time.

Sort of true, but I often hear this take from Java programmers and it feels like &quot;Blub&quot; [1]&#x2F;Stockholm syndrome to me.Personally, I&#x27;m extremely glad to not have had to write .toStream().map(...).collect(Collectors.list()) or whatever in years for what could be a map. Similar with async code and exception handling.For me one of the main advantages of Kotlin is that is decreases verbosity so much that the interesting business logic is actually much easier to follow. Even if you disregard all the things it has Java doesn&#x27;t the syntax is just so much better.[1] <a href="https:&#x2F;&#x2F;paulgraham.com&#x2F;avg.html" rel="nofollow">https:&#x2F;&#x2F;paulgraham.com&#x2F;avg.html</a>

At least where I work, writing new Java code is discouraged and you should instead use Kotlin for backend services. Spring Boot which is the framework we use, supports Kotlin just fine, at the same level as Java. And if you use Jetbrains tools, Kotlin tooling is also pretty good (outside Jetbrains I will admit it is worse than Java). Now, even in new Java projects you can still be using Kotlin because it is the default language for Gradle (previously it was Groovy).

My org had to write a pivotal backend service on the JVM, due to JDBC having the largest number of data source adapters.The choice was Kotlin. Scala is too &quot;powerful&quot; and can be written in a style that is difficult for others, and Java too verbose.Kotlin is instantly familiar to modern TypeScript&#x2F;Swift&#x2F;Rust etc devs.The only negative in my mind has been IntelliJ being the only decent IDE, but even this has changed recently with Jetbrains releasing `kotlin-lsp` for VS Code<a href="https:&#x2F;&#x2F;github.com&#x2F;Kotlin&#x2F;kotlin-lsp" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;Kotlin&#x2F;kotlin-lsp</a>

Java did indeed add more FP to the language, but Java&#x27;s type system is still fairly primitive compared to Scala&#x27;s.

Java&#x27;s new features are always going to be on paper. The ecosystem, with all its legacy code, is always going to be a decade behind. And if you are starting a new project, why would you pick Java over Kotlin?

Outside of Android work, has Kotlin really taken over? My understanding is that Java added a lot of functional programming and that took a lot of wind out of Scala&#x27;s sails (though Scala&#x27;s poor tooling certainly never helped anything).

Why is your personal experience relevant to the wider market? How many companies and locations did you survey for that?

another issue with kotlin, because it encourage Java ecosystem usage like Spring is not much differentiation that could drive adoption.

Kotlin hasn’t made much of an impact in server-side development on the JVM. I’m not sure where this perception comes from, but in my experience, it’s virtually nonexistent in the local job market.

Kotlin is an Android language, because Google says so, and they stiffle Java support on purpose (Java 17 LTS subset currently).Outside Android, I don&#x27;t even care it exists.If I remember correctly, latest InfoQ survey had it about 10% market share of JVM projects.

I was involved in a Scala point version migration (2.x) migration a few years ago. I remember it being painful. Although I recall most of the pain was around having lots of dependencies and waiting for libraries to become available.At the time Scala was on upswing because it had Spark as its killer app. It would have been a good time for the Scala maintainers to switch modes - from using Scala as a testbed for interesting programming-language theories and extensions to providing a usable platform as a general commercially usable programming language.It missed the boat I feel. The window has passed (Spark moved to Python and Kotlin took over as the &quot;modern&quot; JVM language) and Scala is back to being an academic curiosity. But maybe the language curators never saw expanding mainstream usage as a goal.

&gt; Everything is up to date with the new syntax as far as I&#x27;m aware.The Eclipse plugin isn&#x27;t, and none of the newer IDE integrations is reliable.

When I checked a year ago, the IDE tooling still wasn&#x27;t quite there.

Everything is up to date with the new syntax as far as I&#x27;m aware. Also, the compiler and scalafmt can rewrite one to the other. A project can pick whatever style it wants and have CI reformat code to that style.

It&#x27;s on brand for Scala to have multiple ways of achieving the same thing.Now we x2 by having the curly brace syntax and the indent syntax.

Except the reason behind the syntax change is the losing mindshare from Scala into Python, after its relevance in the big data wave that predated the current AI wave.Nothing to do with Haskell, even if it is also white space significant.

You could also have compared it, more attractively, to Haskell.

It&#x27;s been a while since I touched Scala but wasn&#x27;t that a thing in previous versions, minus the braces not being present?

Sorry, I&#x27;m coming from C++-ish background - can anyone explain what&#x27;s going on :)

As a former Scala fan, wow you aren&#x27;t kidding, wth<pre><code> val month = i match
 case 1 =&gt; &quot;January&quot;
 case 2 =&gt; &quot;February&quot;
 &#x2F;&#x2F; more months here ...
 case 11 =&gt; &quot;November&quot;
 case 12 =&gt; &quot;December&quot;
 case _ =&gt; &quot;Invalid month&quot; &#x2F;&#x2F; the default, catch-all
 
 &#x2F;&#x2F; used for a side effect:
 i match
 case 1 | 3 | 5 | 7 | 9 =&gt; println(&quot;odd&quot;)
 case 2 | 4 | 6 | 8 | 10 =&gt; println(&quot;even&quot;)
 
 &#x2F;&#x2F; a function written with &#x27;match&#x27;:
 def isTrueInPerl(a: Matchable): Boolean = a match
 case false | 0 | &quot;&quot; =&gt; false
 case _ =&gt; true</code></pre>

The only issue I have with Scala 3 is Python envy, they should not have come up with a second syntax, and pushing it as the future.If anything is slowly down Scala 3 is that, including the tooling ecosystem that needs to be updated to deal with it.

The bug reports linked on softwaremill and scala GitHub&#x27;s are precise and surprisingly small fixes! It does show Scala&#x27;s power in expressiveness.Scala is a great language and I really prefer its typesafe and easy way to write powerful programs: <a href="https:&#x2F;&#x2F;www.lihaoyi.com&#x2F;post&#x2F;comlihaoyiScalaExecutablePseudocodethatsEasyBoringandFast.html" rel="nofollow">https:&#x2F;&#x2F;www.lihaoyi.com&#x2F;post&#x2F;comlihaoyiScalaExecutablePseudo...</a> Its a great Python replacement, especially if your project is not tied to ML libraries where Python is defacto, like JS on web.

The takeaway of upgrading your libraries when upgrading major language and framework versions applies beyond Scala. Especially when the libraries abuse magic language features (and far too many Scala libraries do) or otherwise integrate deep into the framework&#x2F;language.

That doesn’t follow. Scala is a high level language and compiler above the JVM. The bug here is a high level one:&gt; Turns out there was indeed a subtle bug making chained evaluations inefficient in Scala 3I’m comparing with Haskell, Scheme, or even SQl which all promise to compile efficient code from high level descriptions.

To be fair, it’s misleading to group Scala (or any JVM language), with other “high-level languages.”The JVM is extremely mature and performant, and JVM-based languages often run 5x (or more) than non-JVM high-level languages like Python or Ruby.

I know this topic has been beat to death but this is another example of why high level language with super optimizing compiler has had less industry success.If performance is a feature it needs to be written in the code. Otherwise it implicitly regresses when you reorder a symbol and you have no recourse to fix it, other than fiddling to see if it likes another pattern.

I&#x27;m on Spark Scala 2 project and I hate it. Basically any good Scala dev would never want to work on our ETL projects, so we get second rate Python or Java devs like me who bastardize the language to get anything to work. Most of our new stuff is all pyspark, hopefully we can replace Scala asap.

<a href="https:&#x2F;&#x2F;www.experimental-history.com&#x2F;p&#x2F;bag-of-words-have-mercy-OF.MX.US" rel="nofollow">https:&#x2F;&#x2F;www.experimental-history.com&#x2F;p&#x2F;bag-of-words-have-mer...</a>

Awesome language, nice to see others using it.I can thoroughly recommend it. Once of the best languages out there in terms of expressive power.

It&#x27;s quite impressive that you can swap out major version from under running application and have just one subtle issue.

Thank you for sharing. Interesting insight on dep libraries.

That&#x27;s not true, Spark&#x27;s entire query engine relies on use of runtime codegen via macros&#x2F;quasi quotesLook up the architecture of Catalyst + Tungsten<a href="https:&#x2F;&#x2F;www.databricks.com&#x2F;glossary&#x2F;catalyst-optimizer" rel="nofollow">https:&#x2F;&#x2F;www.databricks.com&#x2F;glossary&#x2F;catalyst-optimizer</a>

Thank you for the clarification. If I understand correctly, these large expressions are created at compile-time, but the impact isn&#x27;t felt until JIT occurs in the runtime environment. In that scenario, shouldn&#x27;t the JIT just run once at startup, though? I&#x27;m still not quite understanding how JIT can take so much time in a production environment.

Macro&#x27;s are compile time, there is no runtime codegen.The problem was overly-frequent inlining generating enormous expressions, causing a lot JIT phase and slow execution.

I’m not familiar with Scala’s macro system, but it seems like a big takeaway here is: Be careful with code that invokes the compiler (JIT) at runtime. That seems like it’s asking for trouble.

Many of the Scala projects got people fired. Something the Scala devs largely ignore. Plus Scala support is truly awful even by the low standards of an OpenSource project. Then there is the fact that the Scala specific libraries are largely dead.Scala had&#x2F;has a lot of promise. But how the language is marketed&#x2F;managed&#x2F;maintained really let a lot of people down and caused a lot of saltiness about it. And that is before we talk about the church of type-safety.Scala is a more powerful language than Kotlin. But which do you want? A language with decent support that all your devs can use, or a language with more power but terrible support and only your very best devs can really take advantage of. And I say this as someone writing a compiler in Scala right now. Scala has its uses. But trying to get physicists used to Python to use it isn&#x27;t one of them. Although that probably says more about the data science folks than Scala.PS The GP is right, they should have focused on support and fixing the problems with the Scala compiler instead of changing the language. The original language spec is the best thing the Scala devs ever made.

&gt; and a decade of tinkering has just fatigued everyone and destroyed any momentum the language once had.it&#x27;s hard to buy it, considering that many of those &quot;fatigued&quot; moved on Kotlin, led by their managers&#x27; bs talking points.

Controversial opinion: Scala should have gone into maintenance mode a decade ago. They got the language right at the beginning, and a decade of tinkering has just fatigued everyone and destroyed any momentum the language once had.

Scala 3 slowed us down?

Turtletoy

Emacs is my new window manager

Damn Small Linux

I failed to recreate the 1996 Space Jam website with Claude

Bag of words, have mercy on us

Dollar-stores overcharge customers while promising low prices

Mechanical power generation using Earth's ambient radiation

PDF: <a href="https:&#x2F;&#x2F;www.stroustrup.com&#x2F;JSF-AV-rules.pdf" rel="nofollow">https:&#x2F;&#x2F;www.stroustrup.com&#x2F;JSF-AV-rules.pdf</a>

The C++ standard for the F-35 Fighter Jet [video]

Google Titans architecture, helping AI have long-term memory

Work disincentives hit the near-poor hardest (2022)

Uninitialized garbage on ia64 can be deadly (2004)

An Interactive Guide to the Fourier Transform

Solving Rush Hour, the Puzzle (2018)

The Anatomy of a macOS App

<a href="https:&#x2F;&#x2F;archive.is&#x2F;jEJAj" rel="nofollow">https:&#x2F;&#x2F;archive.is&#x2F;jEJAj</a>