missinglink VS FrameworkBenchmarks

You can also use the upstream https://github.com/spotify/missinglink if you're using Maven instead of sbt.

There's been a recent release of missing-link with support for Mult-Release JARs and running analysis on multiple projects concurrently. More info here (applies not only to Scala/sbt, so it's worth linking it here): https://old.reddit.com/r/scala/comments/lxmi4w/sbtmissinglink_032_has_been_released_multirelease/

There are still some issues with MissingLink, like that it can't handle Multi-Release JARs (but that's being fixed I write) or that it uses thread-unsafe caches and so it can't be executed in parallel (and so it can take a long time to finish on big projects with many modules). But taken all together I swear by it. It has already saved us from runtime failures after deployment many times (it's easy to get incompatible versions when working on big projects with big number of dependencies). Instead, we get a red build in CI -- just anybody should expect for goodness sake when using a strongly-typed language like Scala.

I have also found that Next.js is shockingly slow.

I recently added some benchmarks to the TechEmpower Web Framework Benchmarks suite, and Next.js ranked near dead last, even for simple JSON API endpoint (i.e. no React SSR involved): https://www.techempower.com/benchmarks/#section=data-r23&hw=...

I discussed it with a couple of Next.js maintainers (https://github.com/vercel/next.js/discussions/75930), and they indicated that it's only a problem for "standalone" deployments (i.e. not on Vercel). However, I'm not entirely convinced that is true. I wonder if there are major optimizations that could be made to, for example, the routing system.

Is it really going to be faster? In the benchmark they cited in the README [0], they are in 10th place among Python frameworks. This is not a real-life benchmark, as it merely expects a hardcoded response. In fact, Robyn’s 10th place is thanks to a feature designed for benchmarks like this, i.e. marking responses as constant [1]. Three more frameworks beat Robyn if you disable this benchmark optimization.

[0] https://www.techempower.com/benchmarks/#hw=ph&test=plaintext...

[1] https://robyn.tech/documentation/en/api_reference/const_requ...

It's a heavily gamed benchmark, but TechEmpower Fortunes is pretty good at revealing the max throughput of a language runtime for "specially tuned" code (instead of idiomatic code).

Java currently beats .NET by about 40%: https://www.techempower.com/benchmarks/#hw=ph&test=fortune&s...

I judge more idiomatic / typical code complexity by the length of stack traces in production web app crashes. Enterprise Java apps can produce monstrous traces that are tens of pages long.

To be fair, ASP.NET Core 9 is a bit worse on that front than ASP.NET Web Forms used to be because of the increased flexibility and async capability, but it's still nowhere near as bad as a typical Java app.

In terms of code length / abstraction nonsense overhead, have a look at the new Minimal APIs for how lightweight code can get in modern C# web apps: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/m...

Lumen sneaks into our top four as Laravel’s little sibling, designed for microservices and APIs. It’s got a minimalist vibe, but here’s the tea: it’s basically Laravel Lite, carrying some of the same heft under the hood. While it’s fast for a Laravel offshoot, its performance lags behind true micro frameworks like Flight or Slim—check the TechEmpower benchmarks for proof.

TechEmpower still does them. https://github.com/TechEmpower/FrameworkBenchmarks/issues/95...

That was a ballpark estimation, and while pure req/sec is usually irrelevant, it still comes in when the load starts to increase and you need to squeeze every last drop of perf.

PHP usually is doing poorly, even with its "cache", and when you realize that PHP devs actually are not PHP devs, but framework (like laravel/symfony) devs you need to account for the overhead of the framework too.

But you can have a look at the framework benchmarks game:

https://www.techempower.com/benchmarks/#section=data-r21&hw=...

This run has .NET 9 in: https://www.techempower.com/benchmarks/#section=test&runid=e...

> that Rust/WASM is likely to become the go to stack for complex web apps

What kind of apps?

On the backend there are plenty of mature ecosystems already that have been around for decades. Even focusing only on performance there's not a huge difference with say .NET or Java when looking at web benchmarks like TechEmpower[1].

On the frontend nothing can really beat the DX of using Vite with JS (hot reload of JS components, styles, etc). I don't know if it's even possible to get hot reload with WASM.

I could be wrong but it sounds like doing a complex web project in Rust would be a pain with not a lot of benefits over more popular and mature solutions.

[1] https://www.techempower.com/benchmarks/#hw=ph&test=fortune&s...

This seems a bit unfair to JavaScript. There’s a lot of optimizations made to the language and its runtimes that have made a more than viable choice for server side applications over the years. The JavaScript that started as a Webbrowser client side language is very different from the ECMAScript that we have today. Depending on its usage it can also be one of the fastest, only regularly eclipsed by rust[1]. So no, JavaScript really isn’t a bad option for server side applications at all.

[1] https://www.techempower.com/benchmarks/#hw=ph&test=composite...