Tobias Pfeiffer

> You realize this person that you are calling an expert

I didn't claim he's an expert, but he did write TruffleRuby, which is still about twice as fast as any other implementation of Ruby six years later: https://pragtob.wordpress.com/2020/08/24/the-great-rubykon-benchmark-2020-cruby-vs-jruby-vs-truffleruby/. So I think it's safe to say that he's at least minimally competent at performance engineering :)

> I'm not really sure how anything I'm saying is even controversial

You're applying rules of thumb you've learned in one context in a context where they are invalid, and then you're accusing people who disagree with you of being ignorant or dishonest, even when it would take you literally 30 seconds to verify that what we're saying is correct, and where one of us literally has a doctorate in the specific topic we're discussing.

> Allocating 8 bytes in 150 cycles might seem fast

150 cycles doesn't sound terribly fast to me, though it'd be pretty good for malloc/free under most circumstances. I presented benchmark results from my 9-year-old laptop where LuaJIT did an allocation every 120 clock cycles, SBCL did an allocation every 18 cycles, and OCaml did an allocation every 9.5 cycles. You can easily replicate those results on your own machine. And that isn't the time for the allocation alone—it includes the entire loop containing the allocation, which also initializes the memory, and also the garbage-collection time needed to deallocate the space allocated. (And,…

I don't think "Agile" is responsible, but it is a supporting character here for sure. Let me give a little history from my perspective.

I got involved in that movement before the word "Agile" existed; I was really interested in the ideas coming from the Extreme Programming folks and had tried them out on a small project in 2000. All of the people I met early on really wanted to do software well; the question was how to do it well and responsively. Unit and acceptance tests were just part of the process [1], and Kent Beck also wrote Test Driven Development By Example [2] around then. So in my view there was strong early interest in quality.

But this was all happening during the rise of the internet, which changed people's expectations for software delivery. Previously, releasing every 18 months was seen as reasonable. Suddenly the web was changing people's expectations. (Although not as fast as you'd think; a consultant pal told me in 2004 that Weight Watchers still had an annual release cycle for their website.) Executives and managers were under pressure to deliver faster.

As I wrote about elsewhere [3], that created a need for Agile that was filled not by the humanistic culture and quality-oriented practices of my end of the Agile world, but by consultants and certification programs watering down the material until executives could slap some new labels on their same old bullshit and call it Agile.

It turns out that bullshit long predates Agile. If you go back to…

This is a polemic, the chapter he refers to is actually a cogent argument: https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=a56b9a7189f07816307ed5bdcb581d1ae1bae032

Basically he traces the origin of the "fallacy" back to "a hodgepodge of
borrowed working-class slang, middle-class prejudice, and archaic economic doctrine" from David Schloss in 1891, and shows it had nothing to do with the 8-hour day effort at the time. The "lump-of-labor fallacy" is essentially a strawman trotted out by opponents of lower hours as a rhetorical device, similar to how the waterfall model never existed before Agile came along as "the alternative". (See e.g. https://pragtob.wordpress.com/2012/03/02/why-waterfall-was-a-big-misunderstanding-from-the-beginning-reading-the-original-paper/)

Then he uses Chapman's theory of hours and some estimates from Denison to show that most likely the 35 hour work week would result in lower unit labor costs, increased demand, and a net gain in productivity overall from the redistribution of working time.

Then he gets into a discussion of fixed costs, and basically says "the government can subsidize the transition by restructuring taxes".

I'm not saying his arguments are sound, although they don't seem obviously wrong, but the chapter is certainly a lot better than the original link, which just summarizes the strawman conclusion but not the evidence.

I learned ruby on a big project about...5 years ago. I've been using it ever since at work and I definitely understand the pain points. With Ruby you really have to learn to understand and appreciate where its strengths are to be productive with it (how close it can bring you to Aspect Orient Programming is probably the biggest).

The only similarity that Elixir honestly has with Ruby is clean syntax and general emphasis on productivity. Everything else is different. Same with Phoenix. On the web side of things it has routes, controllers and views...but there's no magic involved. It's all very clear, explicit and flexible in how it does things. The view layer is honestly one of it's biggest strong points because the way it's handled is the core reason for all of those "My site was faster without caching" articles...but you don't have to work differently to enjoy those gains.

Big Nerd Ranch did a solid write up on the ins and outs of why.

https://www.bignerdranch.com/blog/elixir-and-io-lists-part-2-io-lists-in-phoenix/

This Choosing Elixir for the Code post that came out last month does a really good job of emphasizing a lot of it.

https://pragtob.wordpress.com/2017/07/26/choosing-elixir-for-the-code-not-the-performance/

Seems about right. Luckily, if performance becomes an issue, you can probably scale out horizontally, or perhaps if you don't care much about sticking to the reference implementations, you can consider using alternative ones.

For example, there are benchmarks of some of the Ruby implementations here: https://pragtob.wordpress.com/2020/08/24/the-great-rubykon-benchmark-2020-cruby-vs-jruby-vs-truffleruby/

And here's a paper from 2016 comparing some of the Python implementations: http://kth.diva-portal.org/smash/get/diva2:912464/FULLTEXT01

Of course, performance in real world scenarios and when using larger frameworks (such as Ruby on Rails or Django) may differ from synthetic benchmarks, but it's nice that at least there's work done in creating these alternative implementations. A bit like how we have Hotspot and OpenJ9 for Java as well or even how there's glibc and musl - that way you can choose which implementation is the most suited for your needs, be it for performance reasons or others...

He were are, mostly one developper in only a few years has managed to create ~the fastest R runtime thanks to the graalVM infrastructure
https://github.com/oracle/fastr
+ it get polyglotism for free.

See also graalphp:
https://github.com/abertschi/graalphp/blob/master/results.md

Oracle has managed to create a language framework that enable unprecedented performance and polyglotism but there are no human resources allocated to actually tuning the implementations. Without such framework imagining one developer to implement a language and expect it to outperform the reference vm made by an army of people through decades wouldn't be a realistic expectation but now anythings possible.
Though it would be nice if others companies than Oracle understood the extent of this technological leap.
Actually there is only one: shopify which invest in truffleruby

https://pragtob.wordpress.com/2020/08/24/the-great-rubykon-benchmark-2020-cruby-vs-jruby-vs-truffleruby/