FrameworkBenchmarks

Source for the TechEmpower Framework Benchmarks project (by TechEmpower)

FrameworkBenchmarks Alternatives

Similar projects and alternatives to FrameworkBenchmarks

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a better FrameworkBenchmarks alternative or higher similarity.

Suggest an alternative to FrameworkBenchmarks

Reviews and mentions

Posts with mentions or reviews of FrameworkBenchmarks. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2021-10-15.
  • Prototype GIL-less CPython shows nearly 20x speedups with 20 threads and good single-thread performance. Will the GIL be removed at some point, finally?
    https://www.techempower.com/benchmarks/ is also usually a better suite of benchmarks as they generally try to utilize fuller applications rather than some specific hot-loop benchmark that usually isn't representative of common workloads for that particular runtime (though still good on it's own).
  • AWS Lambda Cold Start Times
    news.ycombinator.com | 2021-10-12
    > “.Net has almost the same performance as Golang and Rust, but only after 1k iterations(after JIT).”

    Additions like async/await and nullable reference types make it easier to write bug-free code, which for a lot of folks is a better trade off than “speaking to the hardware directly”.

    .NET also runs natively on a bunch of platforms now, including ARM.

    I’d call all of that continuous improvement. Perhaps even reinvention?

    [1] https://docs.microsoft.com/en-us/dotnet/core/deploying/ready...

    [2] https://github.com/dotnet/runtimelab/tree/feature/NativeAOT

    [3] https://www.techempower.com/benchmarks/#section=test&runid=5...

  • High Performance HTTP/TCP Thoughts
    reddit.com/r/golang | 2021-10-11
    Apart from those, there's all sorts of rankings at https://www.techempower.com/benchmarks to ogle at, but these are potentially gamed benchmarks, and they may not map to your specific situation (especially: making sure your code isn't the bottleneck). Maybe swapping around the HTTP handling code will net a benefit, but, depending on how much real work the application is doing, maybe it's just not going to save a lot. E.g.: if a typical request takes 4ms to put together due to a couple microservice calls, and you're spending 500 microseconds of that in stdlib HTTP: how much better are things if you somehow magically get a 10x faster HTTP implementation?
  • So You Want to Rust the Linux Kernel?
    news.ycombinator.com | 2021-10-11
    > No, not really. The author, a professional at Microsoft, was a hobbyist with rust who (...)

    It's very hard to believe that "a hobbyist" would, by mere chance, write the absolute best performing framework in the world.

    https://www.techempower.com/benchmarks/

    Your comment not only lacks credibility but also sounds extremely petty.

  • Which Version of JDK Should I Use?
    news.ycombinator.com | 2021-10-10
    If you care about benchmarks and vaguely realistic performance comparisons in the current year, simply have a look at the TechEmpower benchmarks: https://www.techempower.com/benchmarks/#section=data-r20&hw=...

    If you jump around the different tabs that compare which frameworks do what better, on average:

      - .NET is better for plain text
    news.ycombinator.com | 2021-10-10
    .NET has been on Linux for years now. And my company is using it in production on Kubernetes (Linux/Debian). Its crazy how dependable and fast it is. Startup times are amazing and its only getting better each year. We're looking to upgrade to .NET 6 in production by January.

    Have you even seen the benchmarks compared to Java and other languages?

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

    If you're not paying attention to .NET its time to get your head out of the sand, seriously.

  • The Xterm Window Manager Homepage
    news.ycombinator.com | 2021-10-09
    I had a discussion about benchmarks and how useful they are a few days: i remember mentioning TechEmpower in particular because of how close to typical real world usage of the libraries and ecosystems their benchmarks are!

    That said, Vert.X and some other of the frameworks aren't exactly idiomatic Java, because they're heavily focused on maximum performance - when i last checked them out, there were even async JDBC drivers in development, and while the performance was indeed stellar, it wasn't exactly production ready back then.

    Of course, things have probably improved, but perhaps it's also useful to compare some of the full platform implementations and perhaps the most popular of each language's frameworks. Maybe even with ORMs, to also see how those technologies fare in reality, since i've personally seen some of the most widely used enterprise frameworks become pretty slow due to all of the abstraction that's going on, which perhaps is a deserved criticism for Java.

    So for most of the "boring & stable" projects, it could look a bit like the following: https://www.techempower.com/benchmarks/#section=data-r18&hw=...

      - Java, Spring: the most popular enterprise framework in my experience
    news.ycombinator.com | 2021-10-09
    I know this is not a perfect benchmark, but TechEmpower runs benchmarks with tons of different libraries and frameworks, here is the latest round, filtered by just Java and JavaScript technologies: https://www.techempower.com/benchmarks/#section=data-r18&hw=...

    First JavaScript on that list ranks 21th.

    If you check out the complete listing (all languages, https://www.techempower.com/benchmarks/#section=data-r18&hw=...), then a Java program comes at 4th place, after two Rust programs and one C.

    Conclusion, Java is not as slow as people think, and absolutely faster than anything involving JS.

    news.ycombinator.com | 2021-10-09
    Near the top. They never came out on top because languages like C++ would out perform (and now we have Rust too). But Java is certainly up there. That said, recently even a lot of the other languages have made some huge optimisations in the web server space too and so Java doesn’t even dominate amongst the byte code languages like it used it

    https://www.techempower.com/benchmarks/

    news.ycombinator.com | 2021-10-09
    With those particular frameworks, the scene changes a bit and both of them are far more similar in their performance. I'm not sure what the takeaway here would be: whether it's that Wirth's law (https://en.wikipedia.org/wiki/Wirth%27s_law) applies to libraries that try to cover all use cases, that Java just has some popular frameworks which underutilize its potential for performant code, or that you really should compare particular frameworks, paradigms and implementations, rather than just languages in general (since the overhead cannot be disregarded).

    Of course, these results also may not be representative of the stacks that other companies use or even those that are popular in other regions of the world, so i invite you all to check out those results for yourselves with the stacks that you're considering and maybe even browse the test source code: https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast...

  • Faster Python with Guido van Rossum
    news.ycombinator.com | 2021-10-07
    In the case of the TechEmpower benchmarks, i'd argue that it's actually pretty much the same thing as real world applications: https://github.com/TechEmpower/FrameworkBenchmarks

    For example, look at a full platform Java Spring Boot example here: https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast...

    The controller code, the model code and even the repository code are all very reflective of the primitives you'd find in production code.

    The only differences would be when you add additional complexity, such as validations and other code into the mix, such as additional service calls etc., but if even the simpler stuff in Python (as an example) would be noticeably slower, then it stands to reason that it wouldn't get magically faster on the basis of less overhead alone.

    The exceptions to this which i could imagine would be calls to native code, since the aforementioned Python has an amazing number crunching or machine learning support, but that is hardly relevant to web development in most cases.

    Otherwise we risk running into the "No true Scotsman" fallacy: https://en.wikipedia.org/wiki/No_true_Scotsman

    In such a case, we'd adamantly claim that these benchmarks are simply not good enough even for educated guesses and we'd have to build out our full system to benchmark it, which no one actually has the resources for - in practice you'd develop a system and then would have to do a big rewrite, as was the case with PHP and Facebook, as well as many other companies.

    On the other hand, premature optimization and dogmatic beliefs are the opposite end of the spectrum: you don't need to write everything in Rust if using Ruby would get your small application out the door in a more reasonable amount of time.

    There are no easy answers, everything depends on the context (e.g. small web dev shop vs an enterprise platform to be used by millions) and the concerns (e.g. resource usage and server budget vs being the first to market, as well as developer knowledge of tech stacks, for example market conditions of PHP vs Rust).

    Regardless, in my eyes, there's definitely a lot of value in these attempts to compare idiomatic interpretations of common logic for web development primitives (serving network requests in a known set of formats).

    news.ycombinator.com | 2021-10-07
    Those are some pretty nice synthetic benchmarks! However, if you'd like a look at a more real world scenario or two, have a look at the TechEmpower benchmarks as well.

    For example, here are filters for both JS and Python: https://www.techempower.com/benchmarks/#section=data-r20&hw=...

    Do note that for most of the "realistic" stacks out there, you'd probably want to filter out all of the micro or no framework approaches, to compare something like Express and Koa against Django and Flask, like in the following link: https://www.techempower.com/benchmarks/#section=data-r20&hw=...

    Here's the summary page with composite scores across all tests (though you might also want to filter by data storage solution, for example, MySQL): https://www.techempower.com/benchmarks/#section=data-r20&hw=...

    To summarize, the performance from the best to worst currently is:

      Composite scores: Koa (JS) > Express (JS) > Flask (Python) > Django (Python)
  • Guido van Rossum on improving Python's performance
    https://www.techempower.com/benchmarks/ (First Python one is 206'th at the time of this post on the list with https://www.uvicorn.org/ which is marketed as "lightning fast")
  • Common Lisp
    news.ycombinator.com | 2021-10-02
    That's my personal opinion, but I think that programming language pages should have more information density. I also think that using your average "startup template" for Common Lisp is a bit weird. A good example of what I like might be the OCaml homepage https://lisp-lang.org/, the Go homepage https://golang.org/. The Haskell homepage has a REPL with a tutorial, which encourages you to play around with the language, I think that's a good idea https://www.haskell.org/. TypeScript's page is also nice https://www.typescriptlang.org/. For something a little bit different, Dhall is also good at quickly demonstrating how it works https://dhall-lang.org/.

    That might just be a consequence of my time on Hacker News, but I think the insistance on Paul Graham is a bit much.

    The chart about server performance felt a bit weird to me, as I think the difference between Ruby and JS would be bigger at least. So I checked on techempower benchmarks (https://www.techempower.com/benchmarks/) and sadly there is no common lisp. It's also not on the last runs (https://tfb-status.techempower.com/). I think putting the origin of the results and a way to reproduce them would be a good thing. I don't doubt that common lisp is fast, but that diagram looks a bit too much like hollow marketing, especially with the image behind.

    The page about OO (https://lisp-lang.org/learn/clos) has a good explanation of multiple dispatch, but I think it should come with an example. The first steps pages (https://lisp-lang.org/learn/first-steps) also explains atoms well, but it doesn't explain lists after mentionning them.

    In general this feels a bit unpolished, though some part are good. There's no mention of the Common Lisp cookbook (https://lispcookbook.github.io/cl-cookbook/), which sadly confirms a bit the "Lisp users all have NIH syndrome" meme.

  • Ask HN: Who is hiring? (October 2021)
    news.ycombinator.com | 2021-10-01
    - We're the authority on web framework performance (https://www.techempower.com/benchmarks/)

    TECHNOLOGIES

    We don't expect new hires to have experience with all of these, but you'll learn about them every day.

    - Languages: Java, JavaScript, Python, C#

Stats

Basic FrameworkBenchmarks repo stats
145
6,055
9.6
2 days ago

TechEmpower/FrameworkBenchmarks is an open source project licensed under GNU General Public License v3.0 or later which is an OSI approved license.

SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com
Find remote Java jobs at our new job board 99remotejobs.com. There is 1 new remote job listed recently.
Are you hiring? Post a new remote job listing for free.