adding Metaprogramming lessons in Ruby course

[Shoaib19]

Hi,
I’ve noticed that The Odin Project is an excellent resource for learning Ruby, but the metaprogramming topic is currently missing except some intro at Ruby on Rails Advanced Topics. I believe this should be included as part of the Ruby course. I’d like to contribute by adding lessons on this subject.

I propose introducing a new section titled “Advanced Ruby” within the “Ruby course”. After completing this section, learners will gain a solid understanding of dynamic class and method creation, enabling them to apply the DRY principle more confidently and effectively.

here are the topics for the lessons I want to cover:

1. Open Classes
   Ruby lets you reopen existing classes and add or change methods without inheritance.

2. Runtime Method Definition (define_method)
   Methods can be created dynamically while the program is running, often based on data or conventions.

3. Method Lookup & Hooks
   Hooks like method_missing and method_added let you intercept or react to how methods are called or defined.

4. Reflection / Introspection
   Ruby objects can examine themselves to see what methods, variables and ancestors they have.

5. Code Evaluation (eval, class_eval, instance_eval)
   Ruby can execute code dynamically in different contexts, allowing powerful but risky behavior changes.

6. Modules and Mixins
   Modules let you compose and inject behavior into classes, altering method lookup cleanly and predictably.

[JoshDevHub]

Not fully shutting this down, and I'm interested in the what other maintainers have to say about this, but I'm probably a soft "no".

1. I actually really oppose this for Ruby course directly. I think it should be more of a foundation for the Ruby language and OOP. Metaprogramming, although an important feature in Ruby, is a big tangent in that foundational context.
2. I could be more interested in having it as part of the Rails course, where an exploration of metaprogramming may help demystify a lot of Rails constructs (has_many, validates, scope, before_action, and so on). I'm still not entirely sold on this (more on why in the following points), but if it were to be included, that's what would be best to me.
3. We're most focused on getting people into developing fundamentals to the point where they can build and work on full stack web applications. You may think: "well, if you're doing that with Ruby, you should know metaprogramming!" I'm actually unconvinced. I (like a lot of Ruby devs) think that metaprogramming at the app layer is an antipattern 99% of the time. Go ahead and grep TOP's main site for instances of define_method (or other metaprogramming constructs). You won't find any. Do the same with fizzy, an app that is built and maintained by the literal creators of Rails--many of whom are giants in the Ruby/Rails ecosystem. You'll see the same thing. Metaprogramming is a sharp knife. It's very powerful, but also quite dangerous. It reduces a reader's ability to quickly understand the code path for any action. It makes method definitions more difficult to grep. It makes your code more unintelligible to an LSP or an LLM. Metaprogramming is great for library dev when you want to provide consumers a nice, friendly DSL for using your code. The costs usually outweigh the benefits at the app layer though.
4. This is a project driven curriculum. We of course have lessons on various concepts, but these are almost always backed up by projects that give learners the space to get hands on experience with those concepts. This is an important piece of The Odin Project's pedagogy. We have some lessons that talk about Files and Serialization, and then we back that up with the Hangman project where learners work with a dictionary file and can save/load the game (ie. practicing with files and serialization). We have some lessons that talk about Blocks in Ruby, and that's backed up by a Custom Enumerables project where learners make their own version of Ruby's Enumerable module. I think metaprogramming content would need to be accompanied by something that gives learners direct practice with it, and to me, it seems kinda difficult to just come up with good project ideas for it. The best cases are going to be having the learner make some sort of library that provides a DSL. But I can't really think of a good one off the top of my head. A web framework or a testing library would be too much work, as a lot is involved even with stripped down feature sets. Maybe a small HTTP client? Even with that, I'm not so sure.