Much of the difference in optimizability is that C/C++ allows you to do fairly extreme copy elision. This is important because memory bandwidth tends to be a major performance bottleneck.<p>C/C++ code can trivially reach into some remote bit of state and mutate it directly. The compiler rarely objects, no matter how ugly the access method or pattern. It is up to the programmer to make sure the invariants hold and the compiler can’t always see through it. These elided copies add up, though it usually has a maintainability and safety cost.<p>It is related to why functional languages tend to be mediocre for supercomputing in practice despite having nice properties for massive parallelism in theory.
Clojure creator Rich Hickey describes traditional imperative programming as "PLace Oriented Programming (PLOP)" when talking about how Clojure's approach is better for certain kinds of problems.<p>I agree with his point, and Clojure is my favorite programming language, but the computer itself is <i>place-oriented</i>. It runs on reading from and writing to locations in memory, and extracting maximum efficiency from it requires direct control over that memory.
Modern computers are exquisitely sensitive to spatial and temporal locality because many of the hardware features that speed your code up (for free!) take advantage of data or instructions that are “next to each other.” This can be a challenge in a functional program, because not only do you often have little control about where things go, the abstractions that make cool things possible (eg, closures, or lazy evaluation) naturally introduce indirection that hurts locality.
> but the computer itself is place-oriented<p>You could similarly argue that the computer is in fact fundamentally functional, since the core instruction cycle (Fetch Decode Execute) does not modify any memory.<p>The key insight into that system is that we've embedded a functional system within a mechanism that makes it imperative. The functional cycle can output commands to fetch it more data, that it can then use in the next cycle. It becomes imperative by the addition of time, which it needs because it's limited in the amount of input and output.
That's a nice explanation, thanks.<p>Are there any common resources for this kind of access methods and patterns that specifically aim to bridge the soft-/hardware gap? The best one I can come up with is <i>Performance Analysis and Tuning on Modern CPUs</i>[0] by Denis Bakhvalov.<p>[0]: <a href="https://github.com/dendibakh/perf-book" rel="nofollow">https://github.com/dendibakh/perf-book</a>
I recently came across <a href="https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html" rel="nofollow">https://www.kernel.org/pub/linux/kernel/people/paulmck/perfb...</a> , it draws from author's experience about applying optimizations in linux codebase .<p>I also like this very readable paper <a href="https://xnning.github.io/papers/perceus.pdf" rel="nofollow">https://xnning.github.io/papers/perceus.pdf</a>, about reducing the costs of reference counting in context of functional languages.
> lean-zip beats every single compression level miniz_oxide<p>Miniz_oxide is an intentionally simple implementation. It would be more fair to compare it to the newer zlib-rs[1], which even beats zlib-ng (fastest implementation in C)[2].<p>[1]: <a href="https://lib.rs/crates/zlib-rs" rel="nofollow">https://lib.rs/crates/zlib-rs</a><p>[2]: <a href="https://trifectatech.org/blog/zlib-rs-is-faster-than-c/" rel="nofollow">https://trifectatech.org/blog/zlib-rs-is-faster-than-c/</a>
Have you considered exposing these optimisations through a library so programmers can request optimisation passes and have the compiler check the preconditions?<p>Asking cuz I'm preparing an article on how fast JS can get and found the same thing, you can get in 10% of optimised C-code with basically any code if you torture V8 enough (excepting SIMD where there seems to be a bug in V8 where it doesn't optimise to SIMD even when beyond obvious). Figured out I could extract it in a lib and do it more streamlined but not sure how well manual transforms generalise.<p>Also, when working on the roc-deflate, did you find recurring transformations that could fit that model or were most improvements specific to compression?
saying it "beats a crate that has been downloaded X times" is not saying anything other than that is popular. It'd be nice to see slightly more detail there.
This is kind of hacker news post and comments I like; extreme languages on extreme performance with extreme features, not types being added to a language ten gizzilion times slower than a tortoise and the post making anti-type flat-earthers getting freaked out if they have to vaccinate next.
C in indeed a functional language in that most C projects are things that have been observed in real life and have subsequently been uploaded into computers.<p>I'd also like to note that performance is the ULTIMATE concern in a lot of cases.<p>If you have a server that is making 10million requests to a certain method in a minute, then you cannot afford any performance compromise. Any, at all.<p>Rust will never replace C/C++ with regard to high performance computing.
> Rust will never replace C/C++ with regard to high performance computing.<p>I don't buy this. Rust is a lot easier to make more performant than C++ and doesn't really trail behind C in anything but .text size last time I looked. Considering you can easily write C-like Rust that ends up in the same LLVM stack as Clang (more or less) I just don't think this is true outside of some very specific contexts.
AFAIK, I could be wrong or ill informed about this.<p>But, Rust does indeed embedded extra code for much of the functionality that it adds ontop of what C/C++ has.<p>This obviously has a performance hit. Might not be observable on a desktop application but it will be evident on server applications.
> C in indeed a functional language in that most C projects are things that have been observed in real life and have subsequently been uploaded into computers.<p>I don’t think you share the same understanding of functional as TFA uses.<p>Not functional as in “working”/functioning. Functional is meant here as in functional programming, the paradigm.
AFAIK, functional programming is programming that doesn't modify state.<p>And, if all you're doing is taking material from real life and uploading into computers, then you're not modifying state at all.
In the age of powerful LLMs, is there really any reason to program in any higher abstraction than C? Seems like most other languages can be put out to pasture. They were just compromises and shortcuts to make things easier for humans.
Problem specifically in Haskell is that you have to worry about implementing tail recursion to get efficient stack usage. That's not necessary for loops, which Haskell doesn't support. Though other functional languages do support them.
Haskell most definitely supports loops:<p><pre><code> ghci> :{
ghci| for_ [1 .. 10] $ \i ->
ghci| print i
ghci| :}
1
2
3
4
5
6
7
8
9
10
</code></pre>
It doesn't require loops to be implemented at the language level, however. The language is rich enough to support user-defined loop constructs.
This seems to raise the question: is libdeflate fast? My overall impression of libdeflate is that it produces a similar output size to zstd but takes 40 times longer to do it. I realize these are different algorithms of course, but they aren't <i>that</i> different, both being in the Huffman line of the LZ family. So why is libdeflate considered a performance benchmark?
I'm very simple. I see Richard Feldman post. I like it. I'll leave it to the experts as to whether this is a case of <i>opportunistic mutation</i>.
What are some well known programs made with Roc? And I'm curious about the difficulty level of its syntax
There are no well known programs made with Roc. It's been usable for writing real software since July or so for those of us willing to deal with compiler crashes and regular syntax/feature changes. To my knowledge there are six people producing substantial amounts of software in Roc. I'm using it for a speech recognition/transcription app and the desktop environment and apps on my eink tablet, both on my own UI framework.
Well, it has not even reached 0.1.0, so the language is still in early development phase. But it has interesting properties, so I would recommend experimenting with it.