Crystal is not a replacement for Ruby. In the same way that many Algol-like languages are not a straight swap for each other. Don't get me wrong, Crystal is a nice idea but say goodbye to all that yummy Ruby meta-programming which is one of the key things what makes the language so appealing in the first place.

Exactly. As a Ruby developer, Crystal makes me itch. It jettisons exactly what Ruby is valuable to me for: quickly and dynamically building fluent-feeling libraries and tools. It's fast, but I don't need fast--if I don't need Ruby's metaprogramming, I have other, better, established languages to use for those tasks. (Kotlin, C#, Rust, whatever.)

Elixir is kind-of in the same boat for me. I think it's neat and has its place, and BEAM is really cool, but it doesn't scratch the Ruby itch for me. I just don't care about it looking vaguely like Ruby if it's not actually gonna be Ruby.

Have you used a recent (2017) version of Crystal? Quickly building fluent-feeling libraries and tools is exactly my use case for Crystal.

For me, everything that Ruby is valuable for is retained. I'm able to do all the things I did in Ruby just fine, and it prevents me from doing a lot of things I shouldn't have been doing.

We recently migrated our app from Rails to Crystal (using the Amber framework) and our code base is now 2/3rds the size and we eliminated hundreds of bugs in the process simply from static typing and explicit nil handling. Our response times are also now all under 30ms where we were at 100ms+ before.

Until I can perform runtime define_method calls and dynamically construct classes, it doesn't matter what Crystal does. It's fundamentally antithetical to my needs. (JavaScript isn't, but JavaScript is kind of clunky.)

I have Kotlin, C#, C++, and Rust if I need static typing. Ruby is for when I don't.

People think "oh, it's compiled, so I can't have dynamic methods" but that couldn't be more far from the truth. You can do all of that at compile time, and Crystal provides an excellent way of doing so. E.g.: https://github.com/sam0x17/crystal-mongo-orm/blob/master/src...

How late at runtime do these dynamic definitions need to be possible? Just at startup or also after the program has been running for a while?

I occasionally wonder whether it might be possible to accommodate more dynamic language features with a compiler that treats them like a macro system that is expanded statically, such that no actual dynamicism is necessary at runtime.

This is exactly what crystal does

Reading well written source code creates a more efficient workflow than reading api docs. For me, the fact that Crystal is written in Crystal gives it a far greater advantage.

Plus it is faster than Go/Java/Elixir. As others have pointed out, Crystal does have meta programming capabilities.

You can do all of that with really easy to write crystal macros.

You can dynamically build at runtime an HTTP client from an OpenAPI spec (unavailable until runtime, to be clear), method-by-method, using macros? Tell me more.

Yeah use Ruby. I prefer to have well defined interfaces for the objects I use. I love Ruby to death, but it's frustrating to encounter code like this:

  [:thing, :other_thing].each do |msg|
    define_method(msg) do
      @json[msg].to_s
    end
  end

When this is far more clear and, for me, aesthetically pleasing:

  def thing
    @json[:thing].to_s
  end

  def other_thing
    @json[:other_thing].to_s
  end

I'm not sure how you'd use a ruby object that maps to an OpenAPI spec if you don't know what's in the API response until runtime... surely you or the user of your library has an idea what's in the API they are consuming?

You may have an idea, sure, but the alternative is to codegen a new instance of the client library any time anything changes rather than keeping up to date with the API as it evolves and exists. (The moral equivalent is pulling a WSDL during app startup and making sure that you're presenting a correct interface to it.)

I full-stop don't do codegen in any project under any circumstance that is not done strictly within the workflow of a build tool (i.e., a Maven generated-sources gizmo). OpenAPI's options are pretty much all exactly not that: all the codegen options's happy paths seem to be vendoring generated code. And that makes me itch, too.

The example in question is perfectly possible to do in Crystal during compile-time, using macros. What isn't possible is to create a new class on the fly as a sort of magic lookup table that magic methods is called upon. Good riddance, for that functionality.

For the sake of this example, consider [:thing, :other_thing] to be dynamically created at runtime.

Although it probably does not fit your use case something like Common Lisp would shine in a situation like this.

You can build your code at runtime from the spec and then compile it at runtime to get pretty good performance.

Sure. Or I get effectively the same thing with JavaScript. (I just don't much like Node--it's not bad but it's not great--and the dev experience for specifying something like a DSL is a bummer.)

Got me there. First time I've ever in my life heard of a legitimate example where you really do need dynamic methods.

If you're doing stuff with OpenAPI (as I've been doing over the last few weeks), it becomes a pressing thing. =( Generated clients usually are pretty awful, you usually have to generate your own (because they don't publish gems when their APIs change, which is why I've written online-generated ones!), and once you've completed the bootstrap process for an HTTP client, it's as fast as any other Ruby thing. Which is not the fastest out there by a long shot--though JRuby helps--but is Fast Enough for most stuff.

I'm also not sure Crystal can implement an active record pattern off of a database? (Though I am not personally the type to go with that, I prefer row mappers.)

See GraniteORM or my crystal-mongo-orm. You just have to specify your fields at compile time and you are good-to-go. It works just like active record.

https://github.com/amberframework/granite-orm https://github.com/sam0x17/crystal-mongo-orm

"You have to specify your fields at compile time" is exactly not like ActiveRecord, though. That's exactly the downside to it for doing ActiveRecord.

At that point, you may (should) just use an object mapper like ROM that has no model-class hooks at all. (Which I actually like. But the Rails world disagrees.)

You effectively do specify your fields before runtime in Rails, though, in the form of your migrations. Furthermore all of the associations (belongs_to, etc), are arguably also specified before runtime since those helpers run when the class is parsed.

I frequently don't use Ruby-based migrations. I use datastores defined elsewhere and use Sequel as a convenient and easy interface for tasks against those datastores.

You're trying to slice too fine. Crystal can't do this. That's OK. Own it, don't try to hide it.

If the problem is stated as you want a dynamic class to create instances where you call dynamic methods, then yes you need Ruby.

However, that is basically a lookup table using string based dispatch to decide what to execute, and such a lookup table can be done in anything.

Crystal "does" have dynamic methods if you are willing to override method_missing.

No, the dispatch is still decided during compilation.

Wow. I've been checking in on the Crystal ecosystem every few weeks, but I somehow missed Amber. It feels like someone has finally cracked the code that made Rails great.

Elixir is, in my view, an even-more-awesome Erlang with an unfortunate and distracting cosmetic resemblance to Ruby.

Ruby is awesome, as is Elixir, but very different awesome.

Agreed, to be clear. I think Elixir is cool. It just keeps getting framed as a "better Ruby"--though Phoenix might be (probably is) a better Rails.

Take a look at macros in crystal and I promise you 99% of the time you will be able to do what you did in Ruby. Practically everything people do that is "necessarily dynamic" could be done with macros at compile-time. You CAN do things like define the behavior for when a method name is unmatched on an Object or (at compile time) do some string processing and define a bunch of methods based on the results.

Meta-programming in Crystal exists through Macros.