Tobias Pfeiffer

What is less known is that the author of the waterfall model Winston W. Royce recommended doing the entire process TWICE: https://pragtob.wordpress.com/2012/03/02/why-waterfall-was-a-big-misun… It is hard to foresee how the world of development would look like today, had companies used the waterfall process twice on each project.

> Is it something to do with the extreme dynamic nature of the language? Smalltalk/SOM, JavaScript and Lua share the "extreme dynamic nature" but still have much faster JIT implementations. From my reports you can see that V8 (Node) is about ten times and LuaJIT about five times faster than MRI Ruby 3 JIT. Here are some other performance results using the same benchmark suite: https://github.com/smarr/are-we-fast-yet/blob/master/docs/performance.… Also TruffleRuby is reported to perform much better than MRI Ruby JIT (see e.g. https://pragtob.wordpress.com/2020/08/24/the-great-rubykon-benchmark-2…

Ruby doesn't have to be slow anymore! https://pragtob.wordpress.com/2020/08/24/the-great-rubykon-benchmark-2… https://speakerdeck.com/eregon/running-rack-and-rails-faster-with-truf…

Here's a benchmark of CRuby vs JRuby vs TruffleRuby: https://pragtob.wordpress.com/2020/08/24/the-great-rubykon-benchmark-2…

It appears that Ruby 3 might come short of their 3x speedup goal [1][2] ... has anyone tried out Graal/TruffleRuby? Graal/TruffleRuby has shown some massive perf increases [3] [1] https://pragtob.wordpress.com/2017/01/24/benchmarking-a-go-ai-in-ruby-… [2] https://pragtob.wordpress.com/2020/08/24/the-great-rubykon-benchmark-2… [3] https://www.reddit.com/r/ruby/comments/b4c2lx/truffleruby_being_2x_fas…

From benchmarks [1], 2.8.0 (with jit) is ~2x faster than 2.0.0p648 [2]. [1]: https://pragtob.wordpress.com/2020/08/24/the-great-rubykon-benchmark-2… [2]: https://pragtob.wordpress.com/2017/01/24/benchmarking-a-go-ai-in-ruby-…

Great! Benchmarks of TruffleRuby vs JRuby vs Ruby looks very promising. edit: https://pragtob.wordpress.com/2017/01/24/benchmarking-a-go-ai-in-ruby-…

Is it something you'd consider? Even if it's not a performance bottleneck right now it's probably worth it to reduce server costs (more efficient Ruby implementation = fewer servers required to run GitLab.com). Could be looking at serious gains, 3x over CRuby looks to be a fairly reasonable goal when using RubyTruffle (slow startup times can be mitigated against with SubstrateVM), and if that's not an option due to it being a fairly new project, it seems like JRuby could give a decent performance boost too. https://pragtob.wordpress.com/2015/11/30/benchmarking-a-go-ai-in-ruby-… https://m.youtube.com/watch?v=wwEVakQzVAw

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-2…

> 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-2… 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,…

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-2… 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...

> I wrote up a detailed blog post about tail call optimization in Elixir/Erlang and its performance. The TLDR; sort of is that none tail call optimized recursive functions (body-recursive) can be faster and more memory efficient than TCO functions. This is something that I never thought before, that TCO is always faster seems to be a common misconception. My example is also not contrived - it’s an implementation of map. https://pragtob.wordpress.com/2016/06/16/tail-call-optimization-in-eli…

Waterfall never went away, and it can be flexible for anyone that bothers to actually read it properly. https://pragtob.wordpress.com/2012/03/02/why-waterfall-was-a-big-misun… As the author acknowledges most companies never fully embraced Scrum, as not all levels would buy into it, specially into what concerns managing expectations of what gets delivered and development costs mapping to actuall project budgets. So in the end what reigns the corporate world outside startups, are mini-waterfall projects of three weeks.

I agree that Ruby isn't a good fit for every context, but the reasons for Ruby's speed can and are being addressed, this article is extremely accessible and beautiful: http://chrisseaton.com/rubytruffle/deoptimizing/ A few critical C extensions are missing (OpenSSL): https://github.com/graalvm/truffleruby A recent benchmark (FWIW): https://pragtob.wordpress.com/2017/01/24/benchmarking-a-go-ai-in-ruby-…

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… 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-misun… 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 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…

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-… 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-…