News for hackers. Stuff that matters.
Re:The Dynamic Def – abusing Ruby's def statement by msbarnett on Sunday October 18, 2015 @03:36PM (#10409458)

   def some_method
      what_is_this
   end
> You don't know what what_is_this is. It could be an instance variable, a method (anywhere in the inheritance tower), or an autogenerated method from method_missing. It's impossible to tell without digging through the code.

We know it's not an instance variable -- that would be @what_is_this. It would have to be a local variable, but plainly there is no such variable local to this method. So we know it's a method. Let's go hunting (we could do this vis binding.pry, or byebug, or in IRB with an instance of whatever defined some_method):

    method(:what_is_this) rescue false # if false, this is coming from method_missing
    method(:what_is_this).source_location # there's your definition location, if it wasn't coming from method_missing

In general I used to find debugging ruby hard, coming from a background in more static languages. Once I learned the debugging facilities it provides, finding things got a lot easier.
Re:The Dynamic Def – abusing Ruby's def statement by girvo on Sunday October 18, 2015 @04:09PM (#10409584)
Right. Once you understand how to use run-time tooling, debugging dynamic languages becomes rather straightforward.
Re:The Dynamic Def – abusing Ruby's def statement by TeMPOraL on Sunday October 18, 2015 @04:17PM (#10409614)
True. You have to learn to treat programs written in dynamic languages as living, mutable, interactive things instead of designs set in stone. However, when a simple syntax derails your reading, it is a thing of concern.

Then again, you could make similar shenanigans in Common Lisp with `symbol-macrolet', but it's obscure feature that pretty much by definition will be used only by people who know when to use it :).

Re:The Dynamic Def – abusing Ruby's def statement by girvo on Sunday October 18, 2015 @08:00PM (#10410380)
> However, when a simple syntax derails your reading, it is a thing of concern.

Definitely agreed! It's rare that I've come across a set of code that is _so_ over-abstracted or dynamic that reading the code doesn't usually shed light on the issue I'm after, and usually it's a "dense" language (Scala, Lisps, etc.) that manages to achieve that.

Re:The Dynamic Def – abusing Ruby's def statement by TeMPOraL on Sunday October 18, 2015 @10:01PM (#10410703)
Last time I was really, seriously confused about the code was when going through a Scala codebase written by a person deep in love with traits. My problem was less of the syntax or "denseness" and more of nonlocality - every conceptually "whole" algorithm was split into 10 or 20 files and 2 class hierarchies, each having their own hierarchy of traits.

It made some sense in the end, but it took me a lot of time to figure that one out - not because it was complicated, but didn't fit in my head. That the original author was uncooperative and didn't want to explain things too much didn't help either.