DEV Community: Andy Maleh

Ruby Memes 2026-06-12 The "Cool" Reactionary

Andy Maleh — Fri, 12 Jun 2026 22:04:15 +0000

Shareable blog post edition:
https://andymaleh.blogspot.com/2026/06/ruby-memes-2026-06-12-cool-reactionary.html

Andy's Laws of AI in Software Engineering

Andy Maleh — Tue, 09 Jun 2026 18:32:14 +0000

Shareable blog post edition:
https://andymaleh.blogspot.com/2026/06/andys-laws-of-ai-in-software-engineering.html

Law #1: "The more Software Developers use AI, the more valuable Software Engineers who do not use AI become."

Software Engineers who are masters at delivering Software without using AI will actually have increased job security the more Software Developers in the worldwide Software Development community rely on AI to deliver Software without having true mastery over Software Engineering.

As more Software Developers become fully dependent on AI to build Software without truly understanding how AI gets work done, Software Engineers who do understand what is going on under the hood will dwindle and become more valuable than ever. In other words, they will have a competitive advantage over Software Developers who can only deliver Software features with AI as well as Software Developers who have not mastered Software Engineering.

Also, there will always be a need for Software Engineers who can maintain the Software of AI itself.

Law #2: "Software Developers benefit from AI in direct proportion to how weak they are in Software Engineering"

The weaker Software Developers are at Software Engineering the more they benefit from AI. After all, AI learns from Master Software Engineers and then applies its learnings in code generation done for lower-level Software Developers who lack mastery in Software Engineering. So, users of AI simply place themselves lower in the expertise hierarchy to be on the receiving end of what Master Software Engineers feed AI with their code. This explains why many experts like Linus Torvalds do not find AI very useful while devs who have zero degrees and qualifications feel like they get a lot from AI.

A beneficial thing to learn from this law is that it is more valuable for a Software Developer to hone in their Software Engineering skills (including the completion of university degrees) than to hone in their AI usage skills because if they achieve mastery over Software Engineering, they would cease to need AI to do their job well for customers. In other words, if a Software Developer feels like they benefit from AI even a little bit, then that means they have some unhandled weakness and are lacking some skills in Software Engineering they could be improving instead. Using AI after all takes away from the recommended 10,000 hours of Software Engineering practice to achieve mastery.

Law #3: "AI's speed is negated when it produces Software features faster than customers can test and learn."

Code generation is not the bottleneck when customers still have to test every Software feature at a human pace to provide real human feedback before iterating further for future improvement. So, given that customers still need to provide human feedback with non-AI testing, that negates the need for Software Engineers to produce code faster, rendering AI's speed benefits moot. Producing code with Lean Software Processes is fast enough for that need.

Furthermore, Software has a limit to acceptable complexity by customers in relation to how many features it contains. So, if customers get too many features, they get overwhelmed, and that also eliminates the benefits of AI's speed. In other words, customers prefer quality over quantity.

RubyConf has joined RailsConf & RailsWorld as another exclusive discriminatory unexcellent conference

Andy Maleh — Fri, 05 Jun 2026 23:18:46 +0000

(Originally published as this blog post: https://andymaleh.blogspot.com/2026/06/rubyconf-has-joined-railsconfrailsworld.html)

RubyConf has joined RailsConf & RailsWorld as another exclusive discriminatory unexcellent conference by discriminating against any speakers who submit talks that cover Frontend Ruby technologies or dethrone React/JavaScript in any way. In 2025, I won an award for a highly innovative and outside-the-box Ruby open-source project at an international Japanese tech competition that Matz, the creator of Ruby himself, presided on in addition to other judges. My project really impressed Matz, who is the reason for all the Ruby-related conferences existing in the first place, but in spite of that, both RailsConf and RailsWorld rejected my talk about my award-winning open-source project in 2025 despite the Ruby on Rails community sorely needing a Frontend Ruby solution that would fill a gap not handled by Hotwire; that is true Frontend Development in Ruby (to build frontend-local apps like a UML Diagrammer for example). Given that I am the most qualified person to talk about Frontend Development in Ruby on Rails using real Ruby in the Browser, and no other Frontend technologies rival my project in either productivity or simplicity/maintainability, the rejections came across as discrimination/exclusion and mediocrity/closed-mindedness/lack of appreciation for excellence. After all, if you reject an open-source project that won an award by Matz, your action is sending everyone the discouraging message that it doesn't matter how hard Software Engineers work to produce a unique innovation; they will stil be rejected because of discrimination and lack of appreciation for excellence if it comes from outside the core group behind Rails and some of their sponsors/friends. The reason this is also discrimination is because I was not rejected due to being disqualified while the project I want to talk about provides great value to the Ruby on Rails community. It saves Ruby on Rails Software Engineers who use JavaScript libraries like React.js/Angular/Vue/Svelte 6 months of Frontend work every year. I don't know many talks at RubyConf in general that can offer the same benefit. And, I am sure that nobody is as qualified as me on the subject of Ruby Frontend Development, plus no one at either RailsConf or RailsWorld has won a similar award to mine at an international tech competition that was judged by Matz (and I have done it one other time previously too in fact).

Fortunately, this year, my award-winning open-source project got accepted at RubyConf Austria 2026 (30-minute talk) and wroclove.rb 2026 (3-hour workshop). Those conferences are much better run than RailsConf and RailsWorld in welcoming innovation and being inclusive! wroclove.rb 2026 literally says on their website that they "want to confront ideas", in contrast to RailsConf and RailsWorld running away from ideas that don't come from the Rails core devs and some of their sponsors/friends (a form of discrimination). RubyConf Austria & wroclove.rb don't discriminate against Frontend Ruby projects and aren't offended by a talk that dethrones React/JavaScript, especially if already approved by Matz, the creator of Ruby. They welcome the excellence and hard work that went into creating my award-winning open-source Ruby project and winning an award from Matz, the creator of Ruby. In other words, they encourage the Ruby community to be excellent and follow my example in innovation and thinking outside the box. In fact, I met Chad Fowler at RubyConf Austria 2026, and he attended my talk, then told me "good job" afterwards. For those who don't know, Chad Fowler founded RubyConf back in 2001.

So, I submitted my award-winning open-source project's talk to RubyConf in 2026 thinking they might be less averse to Frontend Ruby, especially if the speaker won an award from Matz, given RubyConf is typically more open-minded about Ruby innovations outside of core Rails. Well, I got rejected despite being accepted by Matz, the creator of the language that conference was founded upon. I asked by email for the reasons for the rejection and for feedback to help improve myself in case they want me to do better before getting accepted (though to be frank, I won an award from the creator of Ruby himself, and there isn't anything that can top that). They never responded.

I want to clarify that I have supported RubyConf in the past by giving talks/workshops at it and by donating my speaker stipends/hotel-pay (over $1000 or $2000 for all the conferences I spoke at) back to RubyCentral for the benefit of the Ruby community as a whole with everyone in it. So, it's not much to ask for a response as to why I encountered behavior that came across as discrimination when I have gone above and beyond in the past in supporting RubyConf and RubyCentral.

Eventually, I remembered that I have 2 RubyConf/RubyCentral people as LinkedIn connections, Jason Swett and Freedom Dumlao, so I contacted them asking the same question. I also pointed out to them that I am a former RubyConf speaker who donated his speaking stipends from the last 3 RubyConfs back to RubyCentral for the benefit of the Ruby community at large (that's over $1000). So, being treated with respect and non-discrimination is the least I could expect from RubyCentral.

Jason Swett chose the coward's plea and just never responded, which is how true discriminators handle discrimination when it's raised to them. The reason this incriminates him 100% is because if he truly wasn't involved in discrimination, he would have at least responded by saying he sympathizes with me perceiving discrimination and by indicating he is shocked that a project that won an award from Matz (when many other RubyConf talk projects didn't win any awards from Matz) got rejected at RubyConf. Honestly, Jason reminds me of employees that my employers fired in the past. Lack of presence and visibility is usually the sign of an unreliable employee who is never there for others. So, I advise against hiring Jason Swett (unless he responds to me and clears up my experienced discrimination).

Freedom Dumlao didn't respond to my first message, but at least responded to my 2nd follow-up message. He gets some points for that. Otherwise, his response was very weird and defensive. He claimed with a very unfriendly tone that I didn't know him even though him and I met at RubyConf 2024 and sat at the same eating table multiple times while having conversations that eventually led to connecting on LinkedIn. In fact, it sounded like he was trying to get out of responsibility by claiming I did not know him enough (a very unnice unfriendly thing to say from a Rubyist) even though the world is a meritocracy anyways, meaning people are known through their actions in day to day interactions, whether ethical or unethical. The way he said that came across as immature and irresponsible, not the way someone at RubyCentral should be talking. After all, a responsible person would have not focused on that, yet focused on my experience of discrimination and how strange it is that a project that was approved by Matz in a very difficult international competition and got a "good job" remark from Chad Fowler (the founder of RubyConf) got rejected at RubyConf, which would indicate RubyConf's staff are unqualified and do not appreciate excellence, in addition to having discriminatory biases, like the bias against Frontend Ruby and biases for React/JavaScript that cause offense if they are dethroned (shameful at a Ruby conference that is supposed to make Software Engineers feel safe about loving Ruby more than other languages). None of them have won similar awards from Matz, most likely in fact. A person in Freedom's position should have been sincerely concerned and should have noticed the problem and then promised a solution without making any excuses, just like how excellent organizations behave. Given that he didn't respond that way, even if I didn't know him, his reaction told me and everyone everything about him that we need to know about who he really is. He showed that he's part of the problem not the solution.

Regarding my donations to RubyCentral that exceed $1000, Freedom tried to deny the value of my donation by saying he donated more to RubyCentral, believe it or not! What a creepy disrespectful way to talk to someone who gave you money for free without being required to. Invalidating a donation is NOT a way to encourage people to continue donating, yet sends the message that donations are discouraged because in the end, they won't matter anyways as "someone else donated more than you". That was the most unhinged unprofessional encounter I've had from someone who is supposed to be a professional! Honestly, it doesn't matter how much he donated. My donations still have the same value in helping RubyCentral and the Ruby community regardless. Other people's donations definitely don't invalidate mine.

Freedom also proceeded to claim that there was "no discrimination" because all their talks are reviewed anonymously. EXCEPT, my talk was NOT reviewed anonymously, because it mentions a public project on GitHub (which shows the author as soon as one visits it) and a public award (with the winner's name) that the project won from Matz at a public competition.

I responded to inform him that my proposal submission wasn't anonymous as that was impossible with the talk being about a GitHub project and having won an award. And, I informed him that my donation is definitely NOT invalidated because he donated more. Freedom then chose the coward's plea and didn't respond. I advise against hiring Freedom Dumlao for any jobs or services as a result. He's the kind of selfish irresponsible excuse maker who is only about protecting his own hide while not caring about encouraging and maintaining excellence in a community, nor respecting people who donate to the community without being required to.

You see what i'm dealing with here!? Total trash! These are the kind of people running RubyCentral today! No matter it encountered issues last year with the Mike Perham vs DHH debacle, in addition to stopping RailsConf. The Ruby community is being run by total clowns who are discriminatory, unethical, and unprofessional!

I have ZERO interest in attending RubyConf 2026 as a result. After all, if they rejected a talk by one of the best open-source Ruby projects to come out in 2025 as to win an award by Matz, the creator of Ruby himself, then they probably rejected many other project talks that are top equality because of the lack of qualification of RubyConf staff in 2026. For all we care, we got the dumbest, but most popular, talks in RubyConf 2026, but smart Software Engineers know that popularity is NOT quality. After all, PHP/WordPress is more popular than Rails, but definitely inferior in productivity and maintainability, which is why Ruby on Rails devs don't use those technologies in general.

In conclusion, RubyConf in 2026 has become an exclusive discriminatory unexcellent conference, which is where people go to become dumber and/or meaner.

I have covered the topic of covert discrimination in the Ruby community before. What I encountered at the hands of the RubyConf folks is classic covert discrimination. Spread the word to help stop discrimination and unexcellence in the Ruby community! In the meantime, I'll make sure to only attend and speak at Ruby conferences that don't have unprofessional unexcellent discriminatory staff.

P.S. To prove that I'm reasonable and on the right side of this, I will acknowledge that nobody is perfect and everyone makes mistakes. What distinguishes good people from bad people though is that good people will admit their errors and apologize for their mistakes when they are pointed out to them whereas bad people will act aloof and commit more discrimination/exclusion by ignoring you when that happens. If any of the problematic people mentioned in the article change their mind and decide to respond like real men (not by hiding like cowards) to resolve my concerns about discrimination/exclusion/unexcellence for the benefit of the cheated Ruby community that missed out on all the Matz-loved value provided by an award winning open-source Ruby project that impressed Matz, then I'll delete this blog post.

Presentation Slides for RubyConf Austria 2026 Talk "Frontend Ruby on Rails with Glimmer DSL for Web"

Andy Maleh — Tue, 02 Jun 2026 21:34:17 +0000

My talk “Frontend Ruby on Rails with Glimmer DSL for Web” went well at RubyConf Austria 2026. Especially given that after the talk, Chad Fowler (the starter of RubyConf and famous book author of The Passionate Programmer, among other books) told me “good job”, and Obie Fernandez (a famous entrepreneur and book author of The Rails Way, among other books) told me he will try Glimmer DSL for Web because he doesn’t like React.js.

Presentation Slides Direct Original Long Link:
https://docs.google.com/presentation/d/e/2PACX-1vQ9oBnZpzK_eicVLGSqDmVzhsXsblONEKepnw5_xGHGXTM52JSjaS_ObYUJbx-zkb1M2ul9N2A2MnvU/pub?start=false&loop=false&delayms=60000&slide=id.g140fe579a5a_0_0

Glimmer DSL for Web GitHub:
https://github.com/AndyObtiva/glimmer-dsl-web

I ran a poll at the beginning of my talk, and everyone agreed that they love Ruby and that Ruby is superior to JavaScript, plus the majority indicated that they’d like to write less JavaScript and more Ruby during their Rails web development work. Several attendees told me my talk was great after the talk.

Charles Nutter had me help him with his JRuby workshop afterwards by showcasing my other Glimmer project, Glimmer DSL for SWT, which runs on JRuby. In about 1 minute, I scaffolded a Hello World desktop app from scratch and then packaged it as a native executable on the Mac. Attendees were impressed. So, I’ve participated in presenting 2 events at this conference.

I am very grateful for having such a great experience at RubyConf Austria 2026 overall, especially given that it uniquely included several classical/neoclassical/jazz concerts in between talks that entertained us and relaxed us. Chad Fowler concluded the conference with a beautiful Jazz piano and sax performance. Shout out to Hans Schnedlitz, Muhamed Isabegovic, and Zuzanna Kusznir (plus everyone who helped out) for organizing and hosting such a special Ruby conference!!!

Original blog post version:
https://andymaleh.blogspot.com/2026/06/rubyconf-austria-2026-frontend-ruby-on.html

I published a GitHub repo for the exercises of the wroclove.rb 2026 workshop "Building Rails SPAs in Frontend Ruby with Glimmer DSL for Web". And, Glimmer DSL for Web now has official Rails 8 setup instructions... https://bit.ly/4trJOck

Andy Maleh — Sat, 25 Apr 2026 00:53:13 +0000

Code Master Blog: Exercises for the wroclove.rb 2026 Ruby conference workshop "Building Rails SPAs in Frontend Ruby with Glimmer DSL for Web"

andymaleh.blogspot.com

2025 Reminder That DHH Is a Total Idiot!

Andy Maleh — Fri, 28 Mar 2025 16:42:32 +0000

Just a reminder that DHH is a total idiot for not adding any Frontend Ruby tech to the Rails stack in recent years. For the last 10 years, he's pretended to be "forward thinking" and "innovative", but has been closed-minded and standing in the way of progress. He is not what he used to be when he was open-minded in the minded-2000s and helped merge Merb with Rails. Nowadays, he is clearly biased towards JavaScript against Ruby to the detriment of the Ruby community. He claims he is "embracing" JavaScript for "pragmatic reasons", which might sound good on paper and might be something I'd normally agree with, but in fact is hurting the Ruby community significantly as illustrated by the attached JS code examples that many Ruby on Rails devs write nowadays as a result of DHH's closed-mindedness and stupidity. His claim for embracing JavaScript would only be true if there weren't huge differences between JavaScript and Ruby, alas there are enormous differences between the two languages. As such, DHH is an idiot and will always be called idiot unless he corrects his ways and apologizes for destroying the Ruby on Rails community by enabling devs to write code like the attached code in the last 10 years. The blood of such crappy code is on DHH's hands! Only bigger idiots would support DHH's idiotic position. They're all enemies of progress and innovation in the Ruby on Rails community. We all know Hotwire isn't enough, and the Stimulus bit is the part that many devs replace with React.js eventually or from the get-go because it doesn't solve everything effectively and conveniently. By the way, I do not necessarily propose that everyone needs Frontend Ruby as Hotwire could be sufficient for more basic Rails projects, but 100% of devs who use JS libraries like React/Angular/Ember/Vue/Svelte have zero excuses not using Frontend Ruby instead to cut their work by half with much better possibilities facilitated only by the Ruby programming language. The fact that DHH doesn't get that demonstrates how much out of depth and out of touch he's become in Ruby over the last 10 years.

JavaScript is a disease! Ruby is the cure!

Andy Maleh — Fri, 11 Oct 2024 20:05:58 +0000

In a recent Ruby meetup, I called JavaScript a disease! It is true! Especially, when comparing JavaScript code to much better, more elegant, and more readable Ruby code! JavaScript looks like ugly smelly mold by comparison. Once you see it, you can never unsee it! That's why I wouldn't touch JavaScript with a ten foot pole if I can help it in 2024. I would use Frontend Ruby instead (e.g. Opal Ruby, WASM, or Ruby2JS). Opal Ruby can usually be setup in about 10 minutes in a Rails app (https://github.com/opal/opal-rails), and it yields smaller downloadables than WASM. I am not sure why anyone in 2024 would go through the Hell of JavaScript in their otherwise pristine Ruby on Rails codebase instead of actually entering Heaven by using Frontend Ruby! Opal Ruby has won a Fukuoka Ruby 2023 Award and supports Ruby 3.1 with the ability to use any pure Ruby gems in the Frontend by simply including them in Gemfile. That removes the need for a complicated JavaScript bundling beast like Webpack. In the past, I might have advocated for still using JavaScript in smaller apps, but the barrier of integrating modern Ruby into the Frontend of Rails applications has become so non-existent with Opal, there are no more excuses for using JavaScript in a Ruby on Rails codebase.

Yahuda Katz mentioned in his keynote speech at RailsConf 2014 (https://youtu.be/9naDS3r4MbY?t=1195), which borrowed ideas from Steve Jobs, that by continuously building more floors for the lower levels of a building in the form of a framework and a community of open-source projects, we enable developers to start development at higher and higher levels than they would have been able to otherwise, thus helping them leapfrog earlier ways of development in ever increasing productivity! In 2024, Frontend Ruby (e.g. Opal) is the next floor level that enables Ruby Software Engineers to start at a higher level of development with much higher productivity and maintainability. I strongly believe that anyone who is not using Frontend Ruby in 2024 is at least half as productive as those who are using Frontend Ruby in their Rails development, regardless of whatever framework they are using. I don't care if someone is enamored by some "cool JavaScript framework xyz"; try to implement that framework in Ruby, and IT WILL BE EVER COOLER AND BETTER IN RUBY! Or, in certain instances, you will discover that Ruby is so much simpler than JavaScript, YOU DO NOT EVEN NEED the "cool" JavaScript frameworks as they are UNCOOL IN RUBYLAND! Glimmer DSL for Web is one Frontend Ruby Framework example that demonstrates the unique simplicity/readability of Ruby that is unmatched by cryptic/too-clever JavaScript code: https://github.com/AndyObtiva/glimmer-dsl-web

JavaScript is a disease! Ruby is the cure! Don't be part of the problem by using JavaScript in Ruby on Rails codebases! Be part of the solution by using the language we all love, Ruby, isomorphically in Ruby on Rails applications in 2024 and beyond!

Blog post version for sharing:
https://andymaleh.blogspot.com/2024/10/javascript-is-disease-ruby-is-cure.html

Lack of Support and Participation in the Software Engineering Community Violates The Software Engineering Code of Ethics

Andy Maleh — Mon, 16 Sep 2024 20:06:14 +0000

Some Software Engineers mention "not being interested" as an excuse not to help someone with something that could benefit customers or the Software Engineering community at large when the real reason is in fact covert discrimination against that person and lack of effort to treat them as an equal and equally respected member of their community. Know that Software Engineers have to abide by the Software Engineering Code of Ethics:

https://www.computer.org/education/code-of-ethics

And, it includes the statements:

"Software engineers shall act consistently with the public interest."
"Software engineers shall be fair to and supportive of their colleagues."

So, if someone gives you an excuse of "not being interested" to avoid helping you out with a public interest matter out of discrimination against you, know that they have conducted themselves in an unethical manner and remind them of what they signed up for when they became Software Engineers, whether implicitly or explicitly.

This even extends to matters like Software Engineers not wanting to check out certain technologies/libraries that could greatly help the public interest just out of discrimination against the technology/library creators. It also covers matters of Software Engineers not wanting to learn and improve certain skills through frequent attendance of local user groups that can improve the practice of their profession.

After all, that is covered by the statement:

"Software engineers shall participate in lifelong learning regarding the practice of their profession and shall promote an ethical approach to the practice of the profession."

I am including the short version of the Software Engineering Code of Ethics below for your convenience:

Software engineers shall commit themselves to making the analysis, specification, design, development, testing and maintenance of software a beneficial and respected profession. In accordance with their commitment to the health, safety and welfare of the public, software engineers shall adhere to the following Eight Principles:

PUBLIC – Software engineers shall act consistently with the public interest.
CLIENT AND EMPLOYER – Software engineers shall act in a manner that is in the best interests of their client and employer consistent with the public interest.
PRODUCT – Software engineers shall ensure that their products and related modifications meet the highest professional standards possible.
JUDGMENT – Software engineers shall maintain integrity and independence in their professional judgment.
MANAGEMENT – Software engineering managers and leaders shall subscribe to and promote an ethical approach to the management of software development and maintenance.
PROFESSION – Software engineers shall advance the integrity and reputation of the profession consistent with the public interest.
COLLEAGUES – Software engineers shall be fair to and supportive of their colleagues.
SELF – Software engineers shall participate in lifelong learning regarding the practice of their profession and shall promote an ethical approach to the practice of the profession.

Blog post version for sharing, titled "Lack of Support and Participation in the Software Engineering Community Violates The Software Engineering Code of Ethics":
https://andymaleh.blogspot.com/2024/09/lack-of-support-and-participation-in.html

10x Developer Puzzle, Solved!!!

Andy Maleh — Tue, 03 Sep 2024 19:26:51 +0000

Here is a thought! The mythical 10x Developer is simply a developer that eliminates 9/10 of unnecessary over-engineered code, and then writes the remaining 1/10 of the code needed at the productivity rate of a 1x Developer!

Such a developer might come across as a 10x Developer to others when in fact, all they are is a 1x Developer that knows how to cut the fat of over-engineering out and avoid unnecessary overhyped libraries/languages/technologies to eliminate 9/10 of development waste and only do 1/10 of the work otherwise done.

I believe I have just solved the 10x Developer puzzle for once and for all! The 10x Developer mystery has been demystified for good!!

Originally posted at the Code Master blog:
https://andymaleh.blogspot.com/2024/09/10x-developer-puzzle-solved.html

Glimmer DSL for Web Ruby Integration with JavaScript Libraries

Andy Maleh — Fri, 17 May 2024 21:28:03 +0000

Glimmer DSL for Web is a Ruby-in-the-Browser Web Frontend Framework that enables Rubyists to finally have Ruby productivity and happiness in the Frontend via a simpler, more intuitive, more straightforward, and more productive library than all JavaScript libraries like React, Angular, Ember, Vue, Svelte, etc.... Glimmer DSL for Web's Rails sample app "Sample Selector" has been upgraded with Code Syntax Highlighting by integrating with highlight.js. It demonstrates how to integrate with JavaScript libraries, how to build Glimmer Web Components in the Frontend, and how to make HTTP calls from a Ruby Frontend to a Ruby Backend in a Rails application, among other things.

The Sample Selector Rails app enables users to list all samples that ship with the glimmer-dsl-web Ruby gem, show each sample's entry point code, and run the sample in the browser.

Here is a breakdown of the code:

The Rails layout includes links to the highlight.js javascript CDN URLs:

<!DOCTYPE html>
<html>
  <head>
    <title>SampleGlimmerDslOpalRails7App</title>
    <meta name="viewport" content="width=device-width,initial-scale=1">
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/github.min.css">
    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/languages/ruby.min.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/highlightjs-line-numbers.js/2.8.0/highlightjs-line-numbers.min.js"></script>
    <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
    <%= javascript_importmap_tags %>
  </head>

  <body>
    <%= yield %>
  </body>
</html>

The Rails View renders a Glimmer Web Component using the glimmer_component Rails helper (this is meant to be a drop-in replacement for JS solutions like react_component):

<h1 style="text-align: center;">Glimmer DSL for Web Rails 7 Sample App</h1>

<%= glimmer_component('sample_selector') %>

The Sample Selector Top-Level Glimmer Web Component is the entry point to the Frontend application, which simply consists of 2 other Glimmer Web Components, the Samples Table (samples_table) and the Highlighted Code (highlighted_code). It is as simple as the code could get, and way simpler and lighter than alternative JavaScript library approaches like React, thus cutting down on maintainability cost and time to delivery significantly, for both small and large apps alike:

require 'glimmer-dsl-web'

require_relative 'sample_selector/presenters/sample_selector_presenter'
require_relative 'sample_selector/views/back_anchor'
require_relative 'sample_selector/views/highlighted_code'
require_relative 'sample_selector/views/samples_table'

class SampleSelector
  include Glimmer::Web::Component

  before_render do
    @presenter = SampleSelectorPresenter.new
  end

  markup {
    div {
      h2("Run a sample or view a sample's code.", style: 'text-align: center;')

      highlighted_code(language: 'ruby', model: @presenter, model_code_attribute: :selected_sample_code, float: 'right')

      samples_table(presenter: @presenter)

      button('Run', style: 'margin: 15px 0; padding: 10px; font-size: 1.3em;') {
        onclick do |event|
          event.prevent_default
          markup_root.remove
          BackAnchor.render
          @presenter.run
        end
      }
    }
  }
end

The Highlighted Code Glimmer Web Component declaratively handles loading sample code into an HTML View innerHTML through unidirectional data-binding to the Sample Model code attribute, applying syntax highlighting using highlight.js after reading from the Model whenever updates happen to the View. The code has an excellent separation of concerns between the View and Model, and is a lot simpler than equivalent React code, thus much easier to reason about. Additionally, some CSS was written directly in a Ruby DSL:

class HighlightedCode
  include Glimmer::Web::Component

  attribute :language, default: 'ruby'
  attribute :model
  attribute :model_code_attribute # name of attribute on model that holds code string to render
  attribute :float, default: 'initial'

  markup {
    div(class: 'code-scrollable-container', style: "float: #{float};") {
      pre {
        @code_element = code(class: "language-#{language}") {
          inner_html <= [model, model_code_attribute,
                          after_read: -> (_) { highlight_code }
                        ]
        }
      }

      style {
        r('div.code-scrollable-container') {
          overflow 'scroll'
          width 'calc(100vw - 410px)'
          height '80vh'
          border '1px solid rgb(209, 215, 222)'
          padding '0'
        }

        r('div.code-scrollable-container pre') {
          margin '0'
        }

        r('.hljs-ln td.hljs-ln-line.hljs-ln-numbers') {
          user_select 'none'
          text_align 'center'
          color 'rgb(101, 109, 118)'
          padding '3px 30px'
        }
      }
    }
  }

  def highlight_code
    @code_element.dom_element.removeAttr('data-highlighted')
    # $$ enables interacting with global JS scope, like top-level hljs variable to use highlight.js library
    $$.hljs.highlightAll
    $$.hljs.initLineNumbersOnLoad
  end
end

The Samples Table lists all the samples that are included in the glimmer-dsl-web Ruby gem, and provides the ability to select a sample and run it. It also interacts with a Sample API Web Service to pull sample code data from the Rails backend, thus ensuring a proper separation of concerns for maximum maintainability. Some CSS is added with a Ruby DSL as well:

class SamplesTable
  include Glimmer::Web::Component

  attribute :presenter

  markup {
    table(class: 'samples') {
      tbody {
        SampleSelectorPresenter::SAMPLES.each do |sample|
          tr {
            td(sample.name)

            class_name <= [presenter, :selected_sample,
                            on_read: -> (val) { val == sample ? 'selected' : ''}
                          ]

            onclick do |event|
              event.prevent_default
              presenter.selected_sample = sample
            end
          }
        end

        tr {
          # handle this sample differently via links to demonstrate visiting outside pages
          td {
            span('Hello, glimmer_component Rails Helper!')
            span(' ( ')
            a('Run', "data-turbo": "false", href: '/?address=true&full_name=John%20Doe&street=123%20Main%20St&street2=apt%2012&city=San%20Diego&state=California&zip_code=91911')
            span(' | ')
            a('Code',
              target: '_blank',
              href: 'https://github.com/AndyObtiva/sample-glimmer-dsl-web-rails7-app/blob/master/app/views/welcomes/_address_page.html.erb'
            )
            span(' ) ')
          }
        }
      }

      style {
        r('table.samples') {
          border_spacing 0
        }

        r('table.samples tr td') {
          border '1px solid transparent'
          padding '5px'
        }

        r('table.samples tr td:hover') {
          border '1px solid gray'
        }

        r('table.samples tr.selected td') {
          border '1px solid lightgray'
          background 'lightblue'
        }
      }
    }
  }
end

The Back Anchor provides a back-link to enable going back to the main page from any run sample:

require 'glimmer-dsl-web'

class BackAnchor
  include Glimmer::Web::Component

  markup {
    a('<< Back To Samples', href: '#', style: 'display: block; margin-bottom: 10px;') { |back_anchor|
      onclick do
        back_anchor.remove
        Element['body > *'].to_a[2..].each(&:remove)
        SampleSelector.render(parent: ".sample_selector")
      end
    }
  }
end

The Sample Selector Presenter provides all the data and actions that the Sample Selector View needs, including how to present sample names, the attribute for storing the selected sample, and the method for running a sample, which delegates to the Sample Model to keep concerns better separated for higher maintainability:

require_relative '../models/sample'

class SampleSelectorPresenter
  SAMPLE_NAMES = {
    'hello_world' => 'Hello, World!',
    'hello_button' => 'Hello, Button!',
    'hello_form' => 'Hello, Form!',
    'hello_observer' => 'Hello, Observer!',
    'hello_observer_data_binding' => 'Hello, Observer (Data-Binding)!',
    'hello_data_binding' => 'Hello, Data-Binding!',
    'hello_content_data_binding' => 'Hello, Content Data-Binding!',
    'hello_component' => 'Hello, Component!',
    'hello_paragraph' => 'Hello, Paragraph!',
    'hello_input_date_time' => 'Hello, Input Date/Time!',
    'hello_form_mvp' => 'Hello, Form (MVP)!',
    'button_counter' => 'Button Counter',
  }

  SAMPLES = SAMPLE_NAMES.map { |id, name| Sample.new(id:, name:) }

  attr_reader :selected_sample
  attr_accessor :selected_sample_code

  def initialize
    self.selected_sample = SAMPLES.first
  end

  def selected_sample=(sample)
    # causes selected sample to get highlighted in the View indirectly through data-binding
    @selected_sample = sample

    @selected_sample.fetch_code do |code|
      # causes selected sample code to display in the View indirectly through data-binding
      self.selected_sample_code = code
    end
  end

  def run
    selected_sample.run
  end
end

The Sample Model stores sample specific data like the code and ID, enables fetching sample code from the Rails Backend using a Sample API Web Service, and provides and the ability to run a sample by loading the associated sample Ruby file:

require_relative 'sample_api'

# Sample Frontend Model
class Sample
  attr_reader :id, :name, :code

  def initialize(id:, name:)
    @id = id
    @name = name
  end

  def fetch_code(&code_processor)
    SampleApi.show(id) do |sample|
      @code = sample.code
      code_processor.call(@code)
    end
  end

  def run
    # We must embeded static require/load statements for Opal to pre-load them into page
    case @id
    when 'hello_world'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_world.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_world.rb'
      end
    when 'hello_button'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_button.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_button.rb'
      end
    when 'hello_form'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_form.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_form.rb'
      end
    when 'hello_observer'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_observer.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_observer.rb'
      end
    when 'hello_observer_data_binding'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_observer_data_binding.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_observer_data_binding.rb'
      end
    when 'hello_data_binding'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_data_binding.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_data_binding.rb'
      end
    when 'hello_content_data_binding'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_content_data_binding.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_content_data_binding.rb'
      end
    when 'hello_component'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_component.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_component.rb'
      end
    when 'hello_paragraph'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_paragraph.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_paragraph.rb'
      end
    when 'hello_input_date_time'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_input_date_time.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_input_date_time.rb'
      end
    when 'hello_form_mvp'
      begin
        load 'glimmer-dsl-web/samples/hello/hello_form_mvp.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/hello/hello_form_mvp.rb'
      end
    when 'button_counter'
      begin
        load 'glimmer-dsl-web/samples/regular/button_counter.rb'
      rescue LoadError # the first time a file is loaded, it raises LoadError and must be required instead
        require 'glimmer-dsl-web/samples/regular/button_counter.rb'
      end
    end
  end
end

The Sample API Web Service simply makes HTTP calls to the Rails backend to grab data:

# Sample Resource HTTP API that calls Rails Backend Samples API Endpoint
class SampleApi
  class << self
    def show(id, &sample_processor)
      HTTP.get("/samples/#{id}.json") do |response|
        # Wrapping response body with Native to convert from a JS object to an Opal Ruby object, 
        # thus converting JS properties into Ruby methods that facilitate interaction with object.
        sample = Native(response.body)
        sample_processor.call(sample)
      end
    end
  end
end

In conclusion, we demonstrated in the Sample Selector app a Rails Frontend application that is written fully in Ruby with Ruby DSLs in place of HTML/CSS/JavaScript, is following the Model-View-Presenter pattern (a variation on MVC), includes HTTP calls to a Rails Backend to demonstrate real Business Use-Cases of Frontend/Backend interaction, and integrates with an external JavaScript library (highlight.js) for Code Syntax Highlighting.

As a result, Rails Software Engineers do not have to be split anymore between those who are afraid of Frontend Development because of JavaScript, and those who prefer to do Frontend Development in spite of JavaScript's pitfalls. Instead, there is a 3rd better way that unites all Rails Software Engineers! Just write the Frontend in the same language you love so much in the Backend due to offering maximum productivity and maintainability: Ruby! This should become the no-brainer future of all Frontend development in Rails!!!

I will leave you with the Glimmer DSL for Web introduction from the project README on GitHub:

"You can finally have Ruby developer happiness and productivity in the Frontend! No more wasting time splitting your resources across multiple languages, using badly engineered, over-engineered, or premature-optimization-obsessed JavaScript libraries, fighting JavaScript build issues (e.g. webpack), or rewriting Ruby Backend code in Frontend JavaScript. With Ruby in the Browser, you can have an exponential jump in development productivity (2x or higher), time-to-release (1/2 or less time), cost (1/2 or cheaper), and maintainability (~50% the code that is simpler and more readable) over JavaScript libraries like React, Angular, Ember, Vue, and Svelte, while being able to reuse Backend Ruby code as is in the Frontend for faster interactions when needed. Ruby in the Browser finally fulfills every highly-productive Rubyist's dream by bringing Ruby productivity fun to Frontend Development, the same productivity fun you had for years and decades in Backend Development."

Montreal.rb 2024/03 - Frontend Ruby with Glimmer DSL for Web - Andy Maleh

Andy Maleh — Thu, 07 Mar 2024 18:50:15 +0000

The talk video and slides have been posted for the Montreal.rb March 2024 talk "Frontend Ruby with Glimmer DSL for Web" (Ruby in the Browser Web Frontend Framework).

YouTube Video :

https://www.youtube.com/watch?v=rIZ-ILUv9ME&list=PLRAf4zt5oEjc2mqmEN9m_O0JovQCXxvxt&index=11

Google Slides :

https://docs.google.com/presentation/d/e/2PACX-1vQVihtMktOEJ-AJWb1a-uyJfpyn7q92xstcx7QLIUOFONzG5TmKD7_2hSLdwijgw-l6LdK6OLbQPP61/pub?start=false&loop=false&delayms=60000

Blog Post Announcement :

https://andymaleh.blogspot.com/2024/03/montrealrb-march-2024-frontend-ruby.html

Talk Description :

Rubyists would rather leverage the productivity, readability, and maintainability benefits of Ruby in Frontend Web Development than JavaScript to cut down development cost and time by half compared to using popular yet inferior JavaScript frameworks with bloated JavaScript code as per Matz's suggestion in his RubyConf 2022 keynote speech to replace JavaScript with Ruby. Fortunately, this is possible in 2024!

This talk is a continuation of the previous Montreal.rb talk "Intro to Ruby in the Browser", which ended by promising a new way in the future for developing Web Frontends that would completely revolutionize the way we think about and do Frontend Development using Ruby instead of JavaScript. The future is now!!! The simplest, most intuitive, most straight-forward, and most productive Frontend Framework in existence is here! It is an open-source Ruby gem called Glimmer DSL for Web.

Think of Glimmer DSL for Web as the Rails of Frontend Frameworks. With it, you can finally live in Rubyland in both the Frontend and Backend on the Web! That opens up the door to ideas like rendering Frontend Components in the Backend as Server Components in the future, eliminating the conflict between ERB and JS frontend rendering technologies by leveraging highly readable, maintainable, and productive Ruby code isomorphically.

Slides & Code for RubyConf 2023 Workshop "How To Build Desktop Applications in Ruby"

Andy Maleh — Wed, 15 Nov 2023 03:49:21 +0000

Thanks to everyone who attended my RubyConf 2023 2-Hour Workshop "How To Build Desktop Applications in Ruby". For those who missed the event, I posted the presentation slides and code exercises (27 exercises) on GitHub. I also blogged about the new Color The Circles game app that was developed at the RubyConf 2023 Community Day Glimmer Desktop Hacking event.

More at:

https://andymaleh.blogspot.com/2023/11/rubyconf-2023-how-to-build-desktop.html

GitHub Repo Direct Link:

https://github.com/AndyObtiva/how-to-build-desktop-applications-in-ruby

Presentation Slides Direct Link:

https://bit.ly/rubyconf2023desktop