Sources

Key Points Discussed: **Hype-Driven Development**: This phenomenon describes how software teams often adopt technologies based on trends rather than thorough research and contextual evaluation, leading to potential project pitfalls. **Ruby Trash Talk**: Amr highlights common criticisms associated with Ruby, noting that while these may have valid context, they are not universally applicable. … **Concurrency and Parallelism**: Ruby's limitations in this area are noted, particularly due to the global interpreter lock, which impacts the running of threads. **Syntactical Innovation**: While Ruby's syntax is generally praised, there is a perceived stagnation in innovative features since version 1.9. **Community Engagement**: Amr encourages contributions to Ruby, emphasizing the importance of inclusivity in the community.

So the other said that I could look into using the Qt4 bindings for Python with PyQt4. He mentioned that the Ruby Qt bindings weren’t maintained. … I’ll be the first to admit that’s a bad thing, though. The fact that everything is shoe-horned into Python is a really bad thing. Python is a great language, but it also allows you to write what you think is production level code after a two day bootcamp. That is dangerous. Airflow, notoriously enough, teaches users to run bash scripts from within its Python environment and treats that as a normal thing. Operations engineers who first look at it think that they can run complex shell scripts from airflow and that it’s very safe to do. Data engineers think that data munging with it is easy as pie and then complain that someone else’s DAG brought airflow down. … The ideas I just spoke about seem almost obvious to us now, but they weren’t, back in the day. Smaller frameworks made developers feel productive, but we are left writing a lot of code just to do things the right way, or we can MacGuyver stuff around and YOLO our way into an application that will inevitably break. … ## Implicit not Explicit, Ruby from a Pythonista ### Editor and LSP I experimented with LSPs for neovim, having tried `sorbet` and `solargraph`, I settled on `ruby-lsp`. I think Solargraph had some problem with resolving tests in a rails project, I’m not sure what it was, but I installed Ruby-LSP and it worked without any tweaks. I prefer that for now, but my preference might change eventually. … But after I had gotten over the initial shock, my developer brain immediately wanted to know *how* Ruby managed that. Let’s focus on that. I first ran into something related when I installed a different version of Rails and wanted to downgrade to match the version in the tutorial. Now that made my neurons fire at full power.

None of the none of Ruby's current solutions are on par with those. It's {ts:231} far too conducive to what programmers call foot guns. I never heard that. Features that make it all too easy to {ts:238} shoot yourself in the foot. Huh, that's true. Critically, JavaScript was bad that way, too. Anyway, critically, {ts:245} Ruby's performance profile consistently ranks near the bottom read slows among the major languages. You may remember {ts:252} Twitter infamous fail whale. The error screen with a whale lifted by birds that appeared whenever the service went down. {ts:260} You could say Ruby was largely to blame. … {ts:362} which I'm not sorry to see. Ruby now finds itself awkwardly in middle ground. Uh you may wonder why people are still {ts:369} using Ruby25. It surv it survives because of its parasitic relationship with Ruby on Rails the web framework {ts:377} that enabled Ruby's widespread adoption and it continues to anchor its relevance.

## Cons of Ruby Development ### Fast Development, But Slow Performance Ruby is undoubtedly one of the fastest development languages, but in terms of web application performance, it does not always show the best results. Programming languages like Python and NodeJS are still faster. In most cases, the performance of Ruby is weighed down by the database connections and is dependent on the expertise of the developer and how efficiently their code is written. These issues can create a bottleneck for Ruby, resulting in latency. Twitter struggled with Ruby performance and ended up partially replacing it with code in other languages. Ruby was not completely abandoned, but the system was replaced with Scala solutions. ### Lack of Flexibility Ruby follows standards and paradigms strictly, which creates difficulties in changing the core codebase. This results in flexibility losses because there are many configured set objects that can not be modified by developers. This is one of the biggest disadvantages of Ruby, as it doesn’t allow the developers to make required core changes and necessitates a shift to other tech stacks. ### Improper Documentation Documentation is not always up to date for RubyGems which are heavily involved in application development. While documentation is mostly available for the popular gems, trying lesser-known libraries and gems can mean taking your chances. The developer suffers in this case, as they have to repeatedly check for the required functionality and waste development time.

## Common Challenges Faced by Ruby Developers Working with this dynamic programming language presents a variety of hurdles. Each project can introduce unexpected complexities. Several factors can impact productivity and code quality. From performance issues to managing dependencies, the landscape can be challenging. Developers often find themselves navigating a web of unique situations. One significant concern is performance optimization. Applications built with this language sometimes struggle with speed, especially under heavy loads. It has been reported that up to 48% of Ruby developers encounter performance issues, particularly when scaling applications. This can lead to higher latency and increased response times, ultimately affecting user experience. Another area of difficulty lies in dependency management and versioning. With countless gems available, it can be overwhelming to maintain compatibility across various libraries. Developers frequently deal with conflicts that arise from gem dependencies. A study revealed that nearly 60% of developers face problems related to gem versions. This can lead to wasted time troubleshooting rather than focusing on core functionality. Testing frameworks also pose a challenge. While robust testing is crucial, not all developers adopt best practices. It was found that 54% of Ruby projects lack adequate test coverage. This can result in undetected bugs, complicating future updates and modifications. |Challenge|Statistic| |--|--| |Performance Issues|48% of developers encounter slow application speeds| |Dependency Conflicts|60% face challenges with gem versions| |Lack of Test Coverage|54% of projects are inadequately tested| Understanding these prevalent issues can significantly enhance a programmer's ability to tackle challenges effectively. ... In the world of application development, handling external libraries effectively can greatly impact project success. Dependencies can enhance functionality, but they may also introduce complexity. As systems grow, the risk of incompatibility rises. Navigating these waters requires foresight and strategy. Many developers encounter issues with gems that depend on specific versions. When one library is updated, others may break. This can lead to frustrating debugging sessions. It’s essential to maintain a clear overview of all dependencies. … First and foremost, always update dependencies. Outdated libraries can expose vulnerabilities. In fact, studies show that 75% of reported security issues stem from third-party components. Regularly reviewing and upgrading these elements is vital. Implement automated tools to assist in auditing the codebase. **Testing is another cornerstone of effective upkeep.** Automated tests catch issues early, allowing for swift rectifications. Many professionals recommend employing a mix of unit and integration tests. This helps to ensure that both individual pieces and their interactions perform as expected. ... A big issue we often run into is outdated dependencies causing compatibility issues. Make sure to regularly check for updates and run bundle update to keep everything running smoothly.

I do like Ruby for my own projects. But I hate working on Ruby with others. It becomes more messy faster and then all that supposed “getting out of your way” goes out the window and you have to know about 9 objects, one of which is an iceberg which will need to quack at some point. Overall, it obliterates a programmers ability at local reasoning in code, which is where I really want speed. Cthulhu_ on Dec 19, 2023 I mean I personally believe maintainability is a combination of the language itself and the culture around it; Go is a great example of a language and culture aimed for readability and maintainability, eschewing cleverness. That is, the language is limited in how much cleverness you can write, and the culture is opposed to people trying. … The problem with maintaining Ruby is that Ruby is heavily influenced by Perl. I do like Ruby for my own projects. ... Overall, it obliterates a programmers ability at local reasoning in code, which is where I really want speed.

## The boring superpower: shipping speed ... We started Lago with Rails’ API-only mode, which trims the middleware stack, skips view rendering, and keeps the good stuff: migrations, validations, Active Record, background jobs. That meant less time gluing things together and more time shipping product. ## But what about scaling? One of the biggest criticisms of Rails is that it doesn’t scale. Especially in an age where companies only take months to grow to dozens of millions in ARR, scaling is important. But scale is an architecture and operations problem, not a framework limit. Even at our scale—processing millions of events and API requests—we’re nowhere near the limits (and that’s true for Shopify, GitHub, GitLab etc. too). There are a few reasons for this: … ## The Rails imperfections we live with Some things require discipline on Ruby: - Performance & memory: Do the wrong things and you’ll pay for it. - Concurrency: CRuby’s Global VM Lock means only one thread runs Ruby code at a time. This is where we sometimes offload to Go/Rust. - Magic: Rails can be too fancy. That’s why we favor explicit, boring code and avoid gem dependencies.

Have you found any common obstacles that newcomers to Ruby routinely face? In your opinion, are there any language features that seem more difficult to grasp? Do you find certain patterns that developers with prior OO experience exhibit when first tackling Ruby? … puts "x is even" if x % 2 == 0 Versus the more traditional (but lengthier and less idiomatic): if x % 2 == 0 puts "x is even" end Another stumbling block is the "pure" object oriented nature of Ruby. A lot of developers seem to be used to arbitrarily mixing procedural ideas with object oriented ones. In Ruby you can do this but in reality you'd try to avoid it as much as possible. Even in a similarly dynamic language like Python, there's a heavy reliance on functions.. such as using len(str) rather than str.length, or similar. I find that most of the stumbling blocks come from assuming Ruby is as inconsistent or "mixed" as other languages, when really the standard is to try and keep things as simple as possible. Ruby tends to assume it's easier to learn operators than structural syntax, so while you won't see so much "structural" definitions or endless initiators as in … Regarding certain patterns that existing OO developers find tough, I'd say that from certain languages (such as Java), the lack of multiple inheritance can be "interesting" to start with The existence of modules that are then mixed in to classes can also provide a little bit of a learning curve, but it's mostly about changing expectations than learning anything hard.

## The Challenges Faced by Ruby Developers: Limited Resources and Community Support ### Limited Resources for Ruby Developers One of the main challenges faced by Ruby developers is the limited availability of resources compared to other programming languages. While Ruby has a loyal following and a strong community, the sheer number of resources available for other languages such as Python or JavaScript can be overwhelming. Due to the smaller size of the Ruby community, developers may find it more difficult to find tutorials, guides, and libraries to assist them in their projects. This lack of resources can slow down development processes and hinder the ability to create robust and efficient applications. … ### Challenges with Community Support Another common challenge faced by Ruby developers is the lack of extensive community support compared to other programming languages. While the Ruby community is known for its strong sense of camaraderie and helpfulness, the smaller size of the community can make it challenging to find solutions to complex problems. Unlike larger communities such as those for JavaScript or PHP, the Ruby community may not have as many experts or experienced developers available to provide guidance and support. This can be particularly challenging for newer developers who are just starting to learn Ruby and may require more assistance and mentorship. … ### Common Challenges in Version Compatibility One of the main challenges faced by Ruby developers in terms of version compatibility is the rapid pace of change within the Ruby ecosystem. With frequent updates to the Ruby programming language, as well as the numerous libraries and frameworks that Ruby developers rely on, it can be challenging to keep track of which versions are compatible with each other. Another common challenge is when third-party gems, which are essential components of Ruby applications, are not updated regularly or do not support the latest versions of Ruby. This can result in conflicts between different versions of gems and lead to compatibility issues that are difficult to resolve. Furthermore, as projects grow in complexity and dependencies increase, managing version compatibility becomes increasingly complex. Developers may find themselves spending a significant amount of time troubleshooting compatibility issues, which can slow down the development process and impact project timelines. … ## Common Challenges Faced by Ruby Developers: Performance Issues ### Slow Performance One of the most common challenges faced by Ruby developers is slow performance. Ruby is an interpreted language, which means that it is not as fast as compiled languages like C or Java. This can lead to slower execution times, especially when dealing with large datasets or complex algorithms. To improve performance, Ruby developers can utilize tools like the Ruby profiler to identify bottlenecks in their code. They can also optimize their code by using more efficient algorithms and data structures, caching frequently accessed data, and avoiding unnecessary method calls. … ### Concurrency Concurrency is another common challenge faced by Ruby developers. Ruby is not known for its strong support for concurrent programming, which can lead to performance issues when dealing with multithreaded applications. To address concurrency issues, Ruby developers can use tools like the Concurrent Ruby gem to implement thread-safe data structures and synchronization mechanisms. They can also consider using alternative concurrency models like event-driven programming or actor-based frameworks. ### Gem Compatibility One more challenge faced by Ruby developers is gem compatibility. Ruby gems are packages of reusable code that can be easily integrated into Ruby applications. However, not all gems are compatible with each other, which can lead to conflicts and compatibility issues. To avoid gem compatibility issues, Ruby developers should carefully review the dependencies of the gems they are using and ensure that they are compatible with each other. They should also consider using tools like Bundler to manage gem dependencies and resolve conflicts. … Yo bro, one of the common challenges faced by Ruby developers is the learning curve, especially for beginners. Like, the syntax can be different from other languages which can be confusing at first. I feel ya, man. Another challenge is troubleshooting errors in Ruby code. Sometimes it can be hard to pinpoint where the issue is coming from, causing some major frustration. … One of the challenges I've faced is keeping up with the constant updates and changes in the Ruby ecosystem. Like, new versions of Ruby and gems are released all the time, making it tough to stay current. Oh, I hear you on that one. And documentation can be a real pain too. Like, when you're trying to figure out how to use a gem or a new feature in Ruby and the docs are confusing or outdated, it can really slow you down. … Yo, one of the biggest challenges for ruby developers is dealing with gem dependencies. It's a pain when you update one gem and it breaks another one. Gotta love that dependency hell. <code>bundle update</code> can save you some headache, but it's still a pain.I feel you, man. Another challenge is debugging in Ruby. … Yo, one of the biggest challenges I face as a Ruby dev is managing dependencies. Gem conflicts can be a real nightmare. But what do you guys do to handle those conflicts? Any tips? Hey folks, another challenge I often encounter is debugging. Ruby error messages can be cryptic at times, making it a real puzzle to figure out what's going wrong. Any advice on how to streamline the debugging process?

… 1. Somewhat conflicting opinions expressed across different layers of abstraction that you build into your app over time. 2. In not having an opinion you try to satisfy many ways of solving problems introducing more edge case problems and serious over engineering. The other approach is to build it on a platform that shifts with the changes, i.e. hybrid and web. But if you crack open the source of Cordova, you find all kinds of tangled, unmaintained, bad practice wiring and rewiring. I spent a few months trying to hack Cordova plugins and we decided to just scrap the entire code and build native; fully rewriting the app into a custom framework took 3 months. … That's one of the persistent knocks against rails -- the layers of abstraction. I think that's fair, but it's a tradeoff. You either go along with it because it's advantageous or don't. Once you get familiar with the concepts and the theory of it the framework does what you expect, not a lot of surprises. I'll push back on "temporary" though. ... … Also, resource consumption/optimization. I noticed i need to do something about it on first week of development, which is sad (and spends dev time on non-relevant stuff). Phoenix designed to avoid it (including stupid stuff like N+1 problem) I've worked in multiple languages, and personally enjoy Go and Rust, but nothing, even Django, comes close to the speed I can address a business/user need by using Rails. When running a Startup, you want to quickly be able to try new approaches, and if they suck, you just remove the code and start again, or change. Rails is unmatched that way. It's worth saying that Rails doesn't come with any kind of library for you to abstract business domains and you should avoid callbacks (specifically after_save / after_commit can be really bad in big applications with technical debt), so look for a library for this or write pure Ruby classes. nickserv 9 months ago RoR is great at first but in my experience quickly becomes full of hard to diagnose bugs, its magic metaprogramming seems too tempting for developers to use and leads to all sorts of problems. There is a lack of good quality, well maintenained 3rd party libraries. No such problem with Python, Node, even PHP to a certain extent. … Still for starting out it’s pretty awesome. If your company grows enough that you have legacy data models that no longer fit the designs demanded by customers - First: congratulations, that is awesome. Second: you are either going to want to be very careful how you add new things to your legacy data models, and how you define your boundaries, OR consider migrating off rails. If you start just slapping things on whatever data model is most convenient, to keep up with demands from product, you are going to be in a world of hurt that will take exponentially longer and longer to get out of. I feel like this is one of the mistakes that many developers make, and it's achieving a kind of wisdom to eventually realize it -- that optimizing for DRY above all else creates a mess. I've definitely seen this done in many languages, but I've been mostly using ruby so much these days that I can't actually compare. Do any people who do have deep experience on multiple platforms (these people are few and far between) find this problem is worse in ruby than other places? Maybe it's that ruby gives you tools such that when you do optimize for DRY abstraction above all else you create a bigger mess, compared to other platforms? … Even aside from type safety considerations: in RoR variable bindings appear out of thin air! Imagine onboarding a new developer – not only do they need to learn the arcane language, but then they need to learn a bunch of non-hygienic macros! I remember the lightbulb moment when I was patching Ruby's Devise authentication library to add verifiable credentials to it when I realised that a variable used there is not a 0-ary function, but actually something that is just bound in context by magic. Also, even Rails experts have to go on a hunt to understand magic[2] too! … Rails is a fundamentally unserious framework: 1. It lacks LSP (any modern language should support this, think "clicking" a function call to go to it's definition) 2. it lacks type-safety (do you really want to write unit tests to enforce contracts and expectations in your code? or just use the type system?) 3. Object-Oriented-Programming is a failed paradigm for modern web development 4. elite engineers will not want to work for you

We employed BERTopic modeling and manual analysis to develop a taxonomy of 35 topics, grouped into six main categories. Our findings reveal that Web Application Development is the most commonly discussed category, while Ruby Gem Installation and Configuration Issues emerged as the most challenging topic. Analysis of trends on SO showed a steady decline. A survey of 154 Ruby developers demonstrated that 31.6\% of the participants find the Core Ruby Concepts category particularly difficult, while Application Quality and Security is found to be difficult for over 40\% of experienced developers. Notably, a comparison between survey responses and SO metrics highlights a misalignment, suggesting that perceived difficulty and objective indicators from SO differ; emphasizing the need for improved metrics to capture developer challenges better. ... We identified a hierarchical taxonomy of 35 topics, organized into six main categories of Ruby challenges and a decline in trends of questions on SO. ... Difficulty: Table 1 shows three metrics for difficulty. Ruby Gem Installation and Configuration Issues has the highest percentage of questions without an accepted answer, suggesting that developers encounter challenges when setting up and managing gems in Rails applications. Questions about Search Engines Integration have longer response times, reflecting the complex work involved in configuring advanced search functionalities and managing hierarchical relationships in Elasticsearch. These topics seem to pose unique difficulties, likely due to their technical complexity and critical role in application functionality. … This is likely because these concepts are essential for any Ruby developer and serve as foundational knowledge for those starting with Ruby programming, resulting in relatively straightforward questions. The Development Environment and Infrastructure category emerges as the most difficult while also exhibiting above-average popularity. Software Architecture and Performance is the least popular category, yet it has above-average difficulty. The other three categories are characterized by both moderate popularity and difficulty. This suggests that while questions in these areas are frequently viewed, they present challenges for developers. … For novice developers, 26.54\% expressed that they struggle with Software Architecture and Performance, whereas 54.71\% stated that Data Management and Processing does not present difficulties for them. The perceived difficulty of Core Ruby Concepts versus Data Management and Processing likely stems from their nature. Core Ruby Concepts involve advanced features like metaprogramming and complex methods, which are not essential for routine data management. …

… category, while Ruby Gem Installation and Configuration Issues emerged as the most challenging topic. Analysis of trends on SO showed a steady decline. A survey of 154 Ruby developers demon- strated that 31.6% of the participants find the Core Ruby Concepts category particularly difficult, while Application Quality and Secu- rity is found to be difficult for over 40% of experienced developers. Notably, a comparison between survey responses and SO metrics ... Table 1 shows the 35 topics that we generated with BERTopic, 18 middle categories that were generated with GPT-4o and manual analysis, and the six main categories of Ruby developer challenges. Most of the Ruby developer questions are about Web Application … is a frequent need in many applications. Difficulty: Table 1 shows three metrics for difficulty. Ruby Gem Installation and Configuration Issues has the highest percentage of questions without an accepted answer, suggesting that develop- ers encounter challenges when setting up and managing gems in Rails applications. Questions about Search Engines Integration have longer response times, reflecting the complex work involved in con-