I just saw this post on Reddit today: Why So Serious? | Robby on Rails, and I was wondering where our community falls in regards to “seriousness”.
Ruby has always leaned toward that side of the craft. Toward the part of programming that remembers people are involved. Toward the part that says maybe the code should serve the team… not the other way around.
I don’t think we have too many Ruby egresses these days, but where do you think we value “correctness” more than "ergonomics? Where in the spectrum do you feel we are as a community?
Haven’t read the Wired article Robby links to as it’s behind a paywall but the first two lines of the preview were enough to convince me the author seems to be missing the point:
Ruby Is Not a Serious Programming Language
Ruby survives on affection, not utility. Let’s move on.
There are reasons for the affection, and it’s those reasons why it survives, and imo, exactly what will help it (and others like it) continue to survive in an age of AI
Unless those reasons are given in more detail and they are proven to demonstrate technical superiority compared to most other popular PLs out there, then the original statement stands. “Loving” a language does not have much correlation of how well it solves most problems out there. Many people love language either because of syntax (superficial and unimportant and not a “reason” at all) or because it solved a particular set of problems they had at the time that were important to them which, needless to say, is not “most problems that are important to solve with technology out there”.
I view Ruby as a glorified shell scripting language nowadays. That’s what it really is and it’s not an accident that Homebrew chose it; it fits what they need to do very well because dealing with weird bash-isms can make you want to hang yourself. So they went one abstraction layer above to get rid of endless pointless complexity churn. Ruby absolutely is a very solid choice for their use-case.
We can all selectively and conveniently do the appeal-to-the-masses-fallacy when it suits our bias. We can and should do a better argumentation than that. It’s not intellectually honest. It’s a cop-out: “my favorite thing is popular, hence it’s good”.
At one point in the past burning “witches” was very popular. Was it a good thing to do?
Historically speaking, there is no evidence that popularity correlates with quality. At one point network effects kick in, and they are extremely difficult to nullify; like stopping a huge boulder rolling downhill.
If we want to be even more serious we can even say that Elixir is not a serious PL as well – no static type checking! However, having no static checking is a bliss in Elixir’s niche, as has been discussed to death on this forum (less code written and only enriching it if running in production proves that a certain previously-uncovered case arm must be now covered, being the chief example).
As much as I love Rust I don’t want to prototype with it; I reach for Elixir or Golang for that. Rust only gets summoned once the design has been more fleshed out… and if we really need Rust’s benefits (make most invalid states non-representable and needing ultra speed). Or I am tasked with doing the task in Rust to begin with.
So Elixir is a serious PL because it fills a niche. Ruby, I would argue, barely fills any niches nowadays. The fact that it’s still widely used is more of a testament to the stubbornness of humanity at large, huge organizational risk aversion, and fear of losing one’s career and cushy paycheck by its proponents. It’s definitely not a testament to its technical qualities which are highly unimpressive come 2026.
Ruby is the Perl that refuses to die even though PHP and Python exist for a long time and they ate its lunch ages ago. Which is fine. Use it if it pays your bills. We live in a world where quality always takes a backseat – I don’t judge [too much] the people who are cynical realists and are trying to survive and thrive in this terrible civilization we currently inhabit.
But I’ll not pretend it’s a serious language. It’s not. It’s a toy carried by metric tons of nostalgia.
Exactly, People likes to get validation and will invent all sort of arguments to justify their bias. Similar arguments can be made in many languages., like Perl5 is not a serious programming language! Perl5 survives on affection, not utility!
There is a wide spectrum between correctness and ergonomics and Elixir only covers a narrow space on the spectrum. However, I’d hate it if the space is narrowed down to a singular point.
Bias is an inescapable bug of the organic brain – it is forced to do very aggressive inference and approximation in order to conserve energy. I try hard not to judge but I do prefer pointing people at their bias (and I am grateful when mine are pointed out to me) so we can all collectively improve.
(I tried writing Perl ages ago. Never again, even if I am paid for it. Couldn’t let your remark without a response! The very little I know about it does tell me it survives on affection indeed – regardless if your remark was sarcastic or not – but I would not swear my life on that statement; I’ve seen the horrors that persist in some Linux packages that would be 100% dead if tomorrow Perl disappears.)
I would not mourn if 99% of all PLs get magically deleted from every computer on the planet tomorrow. Because that’s the approximate percentage of PLs that were mostly learning harnesses for their creators and not an objective improvement of the landscape.
Ultimately I believe every single PL / framework will fall in only one of the three camps:
Strongly but dynamically typed languages (like Elixir); you don’t want to have to add tests that assert a function does in fact only works with an integer and not with a float or a string etc. (And I’ve seen that done, more than once, in big Ruby on Rails projects, that make millions every month.) That’s just burning rubber. Languages in this group will be good for prototyping and orchestrating and partial or full self-healing. Very valid niche.
Strongly and statically typed languages (Ocaml, Rust, Haskell, Golang, Zig). When you really want to tighten the bolts and make invalid states non-presentable in code… and maybe also have ultra performance (Rust, Haskell, Zig). We might fit Idris and Coq here for their contribution to an even stronger typing. Ideally at one point we’ll get linear typing and others in the more mainstream languages like Rust and Golang, but it’s highly doubtful. They’ll likely fade at one point and others, even more refined languages, will take their place.
Declarative programming languages that get transpiled by SAT / SMT / other solvers to many other languages in groups 1 and 2. I am thinking stuff like Kubernetes YAML files here: you describe your desired end state and the runtime reconciles what it can currently see versus what you need. IMO declarative programming will one day be the only programming that remains… but it’ll use a few lower-level PLs below (due to my bias I’d think those would be Rust + Elixir but they could be any pair that belongs to groups 1 and 2 respectively).
Any context I’ve seen the term “serious” used, it’s a pure expression of contempt. It never has any significance beyond that. One never describes something positive as “serious”–no one would know what that means. But it’s always quite clear that “not serious” simply means “beneath consideration”, which is fine to have as a private judgment but is hardly constructive as an argument in a public forum. It certainly wouldn’t fly in a professional context, where it would add nothing to the actual arguments for and against. But perfect for language wars I guess where there is no actual problem at hand to be solved.
As someone who used PHP, Python and other comparable languages before encountering Ruby, the appeal of Ruby’s ergonomics was clear and immediate. For various reasons, I was able to be more productive with it and that allowed me to achieve a certain amount of success. Evidently that was also true for a significant number of other developers. If it has been a poor fit in various applications, well, it can hardly be blamed for that. Is a bike not a “serious” mode of transportation because someone failed to ride one to the moon?
Ok, this seems to be turning into an interesting discussion and I was expecting people to have a lot of strong opinions… But let me clarify before this turns into some kinda of flame war :
The reason why I posted is that I’ve worked many many years with other languages (enterprise ones) that are considered more “serious” in contrast to Ruby, and it pretty much shapes how you work with it and how the community interacts with each other (as a set of expectations if you will).
Because of this I have this belief that programming languages (like human languages) also help shape culture and communication. Hence, you are always going to have people that value “correctness” over “ergonomics” and vice versa, so I was wondering where do people think our community gravitate towards.
I think the author’s main point also reminds me a bit of the agile manifesto: “Individuals and interactions over processes and tools” (which I think has been more influential in the past and I’m not quite sure still resonates as deeply with younger developers theses days).
Culture doesn’t reliably reward the serious. Neither does business. It rewards the resonant. The clear. The human. The work that connects. Ruby has always leaned toward that side of the craft. Toward the part of programming that remembers people are involved. Toward the part that says maybe the code should serve the team… not the other way around.
That’s true for human language but not necessarily true for programing languages. In programming, we can pick the best languages to suit the team/culture we have. From my experience, an “enterprise” team is one that has 1~2 guru level leaders and a large member of fungible junior engineers. I guess neither Ruby nor Elixir would be a good fit there.
I stand by what I said. I think every piece of work carries an imprint of its author, and I think it’s undeniable that communities form around shared interests/ convictions. Some even argue that everything is political (but I’m not getting into that). What I see in practice, anecdotal as it may be, is that you can swim against the stream, but the community that forms around a technology, which is ultimately made of people, can have a strong influence on how you end up conducting business.
And history has shown that unless you work on medical appliances / aircraft / financials then barely anyone cares about correctness.
I guess there’s also a beautiful duality in the people vs tech debate, and I tend to agree with you, I think that unless you are working on some mission-critical stuff, people rarely care about correctness, or technology for what matters - and I think there’s an underlying lesson related to tech enshitification as well, but I digress.
I do appreciate Ruby for its impact on tech culture, though, and I like to think that there’s some sort of balance in between where you can make the appropriate tradeoffs. I think we (tech people) tend to think we make decisions purely based on logic, but experience has shown me that’s mostly not true haha .
There is no disagreement here, and we have a prime example in Elixir. However, as compare to other language/frameworks in similar domain, Elixir gives you more leeway to deviate from the “one true way”, so you can “swim against the stream” here and there. For example, I have a strong aversion against scaffolding so I don’t use any of the code generators, and it is perfectly fine in Elixir/Phoenix.
Am I influenced by Elixir? Of course. Do I want to research into the “one true way” as intended by the authors, and treat it as the gospel? No.
Same. And not even only that. Ruby holds a special place in my heart because I was centimeters away from quitting programming back in the dark days of the Enterprise Java horrors. A colleague pointed me at Ruby on Rails and this alone made me decide to continue doing programming as a career.
HOWEVER.
I have witnessed many people let themselves be influenced by a single such pivotal event and carry romantic feelings and nostalgia for much longer than it would be rational for the careers of the most other programmers who are forced to adapt – or can see the cracks and how certain PL quirks waste time and energy that they really should not and so they keep looking for something better.
Ruby helped me both professionally and personally. It showed me that programming can have quicker iteration and be more interesting and involve actual gradual problem solving. It rekindled my hope that it was not all only dreary toiling until retirement.
But it’s a highly unimpressive language and there are multiple items that can be raised – that I’ll skip as this reply became too big already and I am ashamed I semi-monopolised the thread – that demonstrate this.
Ruby should be like the “rebound partner” in the dating lingo: somebody you spend some time with after a toxic relationship, just to see how much different can things be, so you can heal and be open to love again… but in the future, and with another person.
Ruby should be a phase in one’s professional path. Not the final stop. It’s too primitive and raw to be a final stop.
Feel free to open a new thread! I love chatting about that in particular.
This is a property for which I have yet to come up with a name but which I have come to appreciate is very important. I have tried “power” or “powerful”, but it’s not quite right. Maybe it’s easier to explain what I mean by example.
I would much rather write my build scripts in Python than YAML. I would prefer something like JSX to string templates. These are simple examples and should be obvious to most, but this concept can cut quite deep.
I very much like React’s engine and the way it models rewindable code. It’s easy to look at it and say, this is very unsophisticated, we can replace these blunt components with a fine-grained reactive graph. And at first this seems like a great idea, and everything is going fine and it’s very fast, and then you wake up one day and your if statements are components.
And I have picked on Solid here, but you might notice that Phoenix has gone down a similar path as of late with :if and :for. Really, it seems like most tools end up like this, as though it’s some sort of trap which takes very careful and deliberate design to avoid. I am truly impressed that React managed to consistently ship such elegant abstractions for so long (probably not anymore).
But perhaps the truly goated example of this is Erlang, which has delivered on its underlying message passing abstraction for nearly 40 years. Like, this thing has lived through personal computing, the rise of superscalar and multicore processors, the shift from mainframes to commodity hardware, the ossification of that model into “cloud computing”, the entire history of the web, and throughout all of that has maintained relevance as a useful abstraction. I cannot imagine how much wisdom and care must have gone into that.
I hope that, someday, I will be wise enough to design such things. Either way I will keep trying.
Will it? I’ve been downvoted to hell a few times as well. Many HN-ers really don’t like their group-think challenged. I had cases where I was actually toxic and too bitter for such a civilized forum like theirs and I have chatted multiple times with their top moderator – @dang – about it; it was almost therapy and quite the interesting experience in itself. It helped me write my replies in better alignment of what I wanted to say, not what I felt in the moment.
I am not sure why we are even debating a rage-bait article tbh (something we will probably see more of over time because platforms like Wired depend on traffic and many of those platforms are currently suffering - not just because of AI, but because of all the dopamine-hit apps that have got a large chunk of people addicted).
But anyway..
You just contradicted yourself over the course of two paragraphs Dimi… in one you are essentially saying Ruby has no technical merit, and in the other you provide a very solid example
Some of them may or may not resonate with you, but it’s undeniable that Ruby has played an important role in shaping our industry with far-reaching impact and influence, one example is Rails - which many others are still copying or being influenced by to this day. Even our own Phoenix was inspired by and seen as a spiritual successor to Rails, and Elixir itself is influenced by and is widely considered as a child of Ruby.
The author downplaying the impact Ruby has had on the industry is kinda dumb, but like I said, rage-bait gets clicks and I expect they’re in desperate need of them of right now.
Well he’s almost there… many Rubyists say “I came for Rails but stayed for Ruby”
I see many similarities between Elixir and Ruby, especially on the things that aren’t just ‘technical’, things like community, philosophy, culture, intuitiveness, etc. These are all things that can grow a following, technical merit alone, cannot (otherwise we’d all be writing machine code or Assembly).
But each to their own. If that author wants to write-off Ruby (or Elixir), their loss
I did not say Ruby has zero merit. I said it barely has any niches left for it today, and pointed at one that is still very much valid.
Yes, and I recognize that, and said so in following replies.
Crucial detail here being “has played”. Past tense. Time to move on. That’s my chief problem: people hold on to nostalgia and don’t move on. If you want us to argue – attack this one premise. IMO on everything else we can easily agree.
The rest is you mostly appealing to “spiritual” influences that nobody has actually denied. But again, time to move on. I for one don’t plan to sit with my kids or grandkids one day and tell them: “And it all began with Ruby…”, do you?
Would you start a new non-hobby / professional project in Ruby, today? If so, why exactly? What would be the technical and non-emotional justification? Stick to super cold facts only, I am interested.
BTW, I think it’s important to say that I wasn’t trying to promote the original rage-bait article; my intention was to use the reply post as a call for some introspection. I honestly didn’t expect the thread to get this much traction, haha. Still, I really appreciate the thoughtful replies
But that’s the thing: it’s hard to move on. Tools become entrenched both in systems and in the zeitgeist.
It doesn’t help that hype cycles lead to anti-hype cycles. MySQL was bad and everyone knew it, so along came MongoDB. But the creators of MongoDB were negligent and careless, and everyone found out, so the pendulum swung back to Postgres, a database which is ironically mostly worse than MySQL.
And really, I mean, what do you say to that? What do you say to the fact that we are a quarter way through the century and the most hyped tech around is a database with a 30-year-old MVCC storage engine that has to be carefully managed with VACUUMs or it will just randomly explode. Why has this happened?
Why is it that I can’t just spin up 3 or 4 copies of the database and have them network to teach other, form a consensus cluster, and smoothly balance load and tolerate failures? Why am I expected to shard my data by hand? Why do I have to manually fail over when the primary goes down? Why is there a primary? Why do I have to think about this?
Does this technology just not exist? News flash: this technology has existed in production in the real world for nearly 20 years. There have been fully open implementations that you can peek at and understand for nearly 10 years. There is nothing, absolutely nothing remarkable about any of this.
And yet, the other day I read a comment (on Lobsters) where someone lamented that distributed systems are too complicated and brittle and that single-master systems are better and then proceeded to unironically cite GFS as an example. The same GFS which happens to be my favorite distributed systems paper. The same GFS which despite its single master had by far and away the most cursed consistency model I have ever seen. The same GFS which built Google, but which became so legendary for its inability to tolerate faults that they led a massive company-wide initiative to migrate everything off of it, an initiative which was so wide-reaching and painful that their SRE team (the best in the world, at least then) went on to write a literal book about how painful it was.
But it takes time and energy to change the zeitgeist, and people don’t know any better. They don’t know the reason that distributed systems were so unreliable and brittle was that their designers didn’t understand how to properly test them, i.e. a pure skill issue. They don’t know that this problem was entirely solved by the pioneering work on practical Deterministic Simulation Testing by the FoundationDB team over 15 years ago, a torch carried today by the Tigerbeetle team, the Antithesis team, and, at least a little bit, by myself.
And yet I come onto this niche forum for a programming language which is (at least ostensibly) designed for building distributed systems, and I utter the accursed words “unit tests are bad actually”, and immediately four people come out of the woodwork (including you Dimi!) to complain that they think that unit tests are good, and of course I cannot possibly blame any of you, because you don’t know any better, and I know that very recently I did not know any better, until I actually tried writing unit tests for a database and learned by suffering that you cannot do that.
Time to move on. Or perhaps, it takes time to move on
I share your frustration with the current state of affairs and it is very justified – but putting words in my mouth (or that of others) is undermining the rest of your argument. Show me where I “came out of the woodwork” and “complained that unit tests are good”. There is no such thing. I am fairly sure my tone was not outraged or defensive there. And I vaguely remember saying that for your work normal unit tests indeed are more or less indeed useless but that for normal CRUD work – one that most of us [are forced to] do – they are quite necessary. To what extent and if many people are overdoing them is an interesting discussion but not in this thread.
Probably the reason for your rather uncharitable statements is that there is context that is not dear to your heart and is not close to your mind, as demonstrated right here:
…which is definitely a part of the issue but it’s more like a consequence and not a root cause. A symptom of the sickness, not the actual sickness.
The root cause is the eternal race to the bottom that 99.99999% of people working in IT have to endure and just watch helplessly how the entire area sluggishly staggers and stumbles, making one drunken accidental step in 3 years, whereas just a few hundred talented individuals can make it jump 100 meters in a fraction of the time.
You think I and many others didn’t understand the limitations of the tech we worked with, and those we still work with? I knew Java was not fit for purpose of what was coming (apps with many parallel users)… back in 2005, after I worked with it for a year and half. Thousands of other examples exist. Including my unpopular opinion about Ruby in this very thread.
I am not Lara Croft. I can’t work on whatever tickles my fancy that season. I am forced to go where the money is because I want to eat, be able to travel every now and then and buy a house and at least not be afraid of banks seizing the property where I sleep, at the twilight of my life.
(Commercially and career-wise I started regretting picking Elixir. If I can’t find a stable employment with it in the next 1-2 years, I am jumping ship. You heard it here first!)
You seem to come from a privileged position, if you allow me an assumption that’s partially backed by observing your comments on this forum. It’s very easy to assume others are unskilled but you’d be missing the forest for the trees if you go down that (rather contemptuous) path.
And hey, look, I get it. You and I and many others seem to indeed come from the 575th century (sadly I am sure nobody will get that reference ) and we are wondering WTF are we doing here in the barbaric ages. I struggle with this my entire life.
But I invite you to be our brother in arms, not an aristocrat scoffing to himself: “Hmph. Peasants!”
(And I know you’ll deny doing that. But I feel obliged to tell you what does it look like you are projecting outwards. I know you don’t mean ill but you should work on your presentation.)
BACK ON TOPIC FOR A MINUTE.
The latter part is IMO the root cause. Human brains are intrinsically extremely limited due to running on sugars and producing those in enough amounts for the brain to work even better will accidentally destroy all the machinery that keeps the brain alive so yeah, well, human brains do extreme inference and extrapolation in order to be energy-efficient (as mentioned in a previous comment). Which leads to them going with the flow and not caring. And doing sweeping generalizations.
Combine that with the fact that most people in IT are there just for the money which adds one more extremely strong temptation to just do the bare minimum and never rock the boat.
Et voila, welcome to the state of IT come 2026. Oh well.
:
.
HOWEVER. 
) and we are wondering WTF are we doing here in the barbaric ages. I struggle with this my entire life.
BACK ON TOPIC FOR A MINUTE. 
