Happy Birthday, Ruby

Post by evdubs » Thu, Jan 10, 2019, 9:33 PM UTC

christophilus wrote: post #162

Slackwise wrote: post #150

Earlier quoted context omitted.

(def fizzbuzz-nums (range 1 101)) (defn fizz? [n] (zero? (% n))) (defn buzz? [n] (zero? (% n 5))) (defn fizzbuzz? [n] (and (fizz? n) (buzz? n))) (defn fizzbuzz [n] (cond (fizzbuzz? n) "FizzBuzz" (fizz? n) "Fizz" (buzz? n) "Buzz" :else n))) (def fizzbuzz-list (map fizzbuzz fizzbuzz-nums)) (apply println fizzbuzz-list)

Simple. But this brings up a debate I've been having with some folks. I have the memory of a gnat, so I can't keep a lot of context in my head. I prefer the previous two examples to this one, simply because with this one, I have to remember a lot more contextual vocabulary. It's a pet-peeve of mine to pull up a source file, and then have to ping-pong around between 50 different function calls, when the entire thing c…

Post by innocentoldguy » Thu, Jan 10, 2019, 9:37 PM UTC

marcolussetti wrote: post #29

kemenaran wrote: post #13

I'm currently working on a Ruby project, and I love the language so much! It's elegant, fast enough for me, and the ecosystem rocks. It seems that, after Ruby borrowed from many previous languages, a lot of rubyisms went into Rust (the nice functional-style enumerations, the awesome package manager inspired by Bundler). And I'm thrilled the best of the Ruby world found its way into other languages. A future where the…

Wouldn't Crystal fit the bill for a fast compiled language explicitly designed to emulate Ruby's syntax? (I don't have any significant Ruby or Crystal experience, so if there are reasons why that doesn't fit the bill, I'm sorry)

Post by smitherfield » Thu, Jan 10, 2019, 9:41 PM UTC

jpatokal wrote: post #170

smitherfield wrote: post #149

Earlier quoted context omitted.

#!/usr/bin/env ruby puts((1..100).map do |n| "#{:Fizz if (n % 3).zero?}"\ "#{:Buzz if (n % 5).zero?}" .then .find { |s| !s.empty? } || n end)

I'm curious: do you genuinely find that beautiful?To me all the enumerable/map/frozen string literal stuff seems pointlessly overcomplicated compared to the simplicity of just writing down what you're supposed to do: (1..100).each do |n| a = String.new a (Disclaimer: not my code, on mobile so I stole that off GitHub)

  #!/usr/bin/env ruby
  # frozen_string_literal: true

  module FizzBuzz
    Integer.include self

    def self.array(enumerable = 1..100)
      enumerable.map(&:to_fizzbuzz)
    end

    def to_fizzbuzz
      "#{:Fizz if (self % 3).zero?}"\
      "#{:Buzz if (self % 5).zero?}"
        .then
        .find { |s| !s.empty? } || to_s
    end
  end

  puts FizzBuzz.array

Post by beforedawn » Thu, Jan 10, 2019, 9:42 PM UTC

moojd wrote: post #122

swat535 wrote: post #93

Earlier quoted context omitted.

Your complaints regarding ruby has been noted. It's not you favorite language and that's cool. Every language out there has pros and cons with different set of tradeoffs , you can't point at a language and objectively say X is better than Y. Ruby has its place and whilst you think Rails is "magic" the internet begs to differ. Of course any framework looks like "magic" if you don't bother digging into implementation d…

"Ruby has its place and whilst you think Rails is "magic" the internet begs to differ. Of course any framework looks like "magic" if you don't bother digging into implementation details of it. That is the whole point!" I think most people including many Rails proponents would agree that Rails has a huge emphasis on "magic" compared to other frameworks. It's a feature. Convention over Configuration implies magic and t…

Post by sevensor » Thu, Jan 10, 2019, 9:46 PM UTC

sethrin wrote: post #172

sevensor wrote: post #133

The decision to implement DSLs by overriding method_missing seems to have opened a can of worms and the community has never managed to put the lid back on. More than anything else, this is the thing that seems to cause no end of consternation with Rails. At the same time, it's pretty much the defining feature of Rails.

I'm not aware that this has caused much consternation. I disagree that DSLs are a defining feature of Rails. There are other ways to implement DSLs besides `method_missing`, and rubocop and other style guides warn against using this method.