cps VS FrameworkBenchmarks

This'll get you closer: https://github.com/nim-works/cps

Sorry, I was in a hurry.

- https://github.com/nim-works/cps

Or a neural network DSL or for a self-contained example, einsum:

There has been a more-or-less working CPS implementation for Nim for a few years now,

https://github.com/nim-works/cps

https://github.com/nim-works/cps/tree/master/docs

Nobody seems to care though, as it has gained no traction at all and it has been mostly ignored by the core team.

Ones that have not been mentioned so far:

nlvm is an unofficial LLVM backend: https://github.com/arnetheduck/nlvm

npeg lets you write PEGs inline in almost normal PEG notation: https://github.com/zevv/npeg

futhark provides for much more automatic C interop: https://github.com/PMunch/futhark

nimpy allows calling Python code from Nim and vice versa: https://github.com/yglukhov/nimpy

questionable provides a lot of syntax sugar surrounding Option/Result types: https://github.com/codex-storage/questionable

ratel is a framework for embedded programming: https://github.com/PMunch/ratel

cps allows arbitrary procedure rewriting to continuation passing style: https://github.com/nim-works/cps

chronos is an alternative async/await backend: https://github.com/status-im/nim-chronos

zero-functional fixes some inefficiencies when chaining list operations: https://github.com/zero-functional/zero-functional

owlkettle is a declarative macro-oriented library for GTK: https://github.com/can-lehmann/owlkettle

A longer list can be found at https://github.com/ringabout/awesome-nim.

I think the CPS attempt in Nim could do this

https://github.com/nim-works/cps

* Goroutines are probably a lot more easier to use. Work is being done to make Nim even better in that area: https://github.com/nim-works/cps but don't expect it soonish.

* I feel like Go has less 'edge cases', but the Nim compiler is steadily getting more stable, especially consider it's not backed up by a major company!

* Metaprogramming is really powerful, but not beginner friendly. The documentation says use macros when necessary, but personally I don't think that really happens in practice.

The advantages by far outweigh the disadvantages, especially if you are looking for a clean Go alternative(except maaaaaaybeee web application).

and the fifth: https://github.com/disruptek/cps

Since 2013, TechEmpower has established a backend framework benchmark. They meticulously define benchmark specifications and maintain an open-source approach that encourages contributions from the community. This benchmark has become a respected standard in the tech industry, serving as a reliable yardstick for technology competitors to assess the performance of their solutions (exemple Go Fiber, C# Asp.net, JS Just). So I can trust the Techempower benchmark.

Interested to see how this fares on Tech Empower's benchmarks: https://www.techempower.com/benchmarks/#hw=ph&test=fortune&s...

At the moment it is at the bottom as a "did not complete"

It seems like Rust is doing a pretty good job of applying to web apps and APIs:

https://www.techempower.com/benchmarks

It would still be slower :P

At least once you start "gaming" benchmarks interpreted and/or dynamically typed languages have a strict ceiling they can't really surpass (just.js doesn't count as it's as thin wrapper on top of C as it can get)

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

(all top entries are bottlenecked by DB driver implementation and its ability to multiplex queries, and context switching cost, so those frameworks which can do perfect static partitioning and query multiplexing win out)

Neat. Thanks for sharing!

Interestingly, may-minihttp is faring very well in the TechEmpower benchmark [1], for whatever those benchmarks are worth. The code is also surprisingly straightforward [2].

[1] https://www.techempower.com/benchmarks/

[2] https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast...

ntex was formed after a schism in actix-web and Rust safety/unsafety, with ntex allowing more unsafe code for better performance.

ntex is at the top of the TechEmpower benchmarks, although those benchmarks are not apples-to-apples since each uses its own tricks: https://www.techempower.com/benchmarks/#hw=ph&test=fortune&s...

Ruby is slow. Very slow. How much you may ask? https://www.techempower.com/benchmarks/#hw=ph&test=fortune&s... fastest Ruby entry is at 272th place. Sure, top entries tend to have questionable benchmark-golfing implementations, but it gives you a good primer on the overhead imposed by Ruby.

It is also not early 00s anymore, when you pick an interpreted language, you are not getting "better productivity and tooling". In fact, most interpreted languages lag behind other major languages significantly in the form of JS/TS, Python and Ruby suffering from different woes when it comes to package management and publishing. I would say only TS/JS manages to stand apart with being tolerable, and Python sometimes too by a virtue of its popularity and the amount of information out there whenever you need to troubleshoot.

If you liked Go but felt it being a too verbose to your liking, give .NET a try. I am advocating for it here on HN mostly for fun but it is, in fact, highly underappreciated, considered unsexy and boring while it's anything but after a complete change of trajectory in the last 3-5 years. It is actually the* stack people secretly want but simply don't know about because it is bundled together with Java in the public perception.

*productive CLI tooling, high performance, works well in a really wide range of workloads from low to high level, by far the best ORM across all languages and back-end framework that is easier to work with than Node.JS while consuming 0.1x resources

Although that seems to have improved in recent years.

https://www.techempower.com/benchmarks/#hw=ph&test=json§...