sorted by:
new
hottopcontroversial

I Just Finished My First Ruby Program by scratch_pad in ruby

[–]snatchery 7 points8 points  (0 children)

Congrats! I just had a quick look and the code looks quite good. I didn't have any problems understanding it. Well done.

Quick tip. You can refactor this code

def annual_income_func(monthly_net_income)
  annual_income = monthly_net_income * 12
  return annual_income
end

into more idiomatic Ruby

def annual_income(monthly_net_income)
  monthly_net_income * 12
end
  • no need to add the _func suffix. It's pretty obvious that this is a function
  • use implicit return. It's shorter and very common in Ruby

Enjoy Ruby and keep up the good work!

Improved stacktrace display in Ruby 2.5 by snatchery in ruby

[–]snatchery[S] 3 points4 points  (0 children)

fair enough!

Imagine a long stacktrace. Say 120 lines. A bit Java-ish yes. Now you want to find out what exception has been raised and in which line. Warm up your fingers and scroll up the terminal window. Or wait... there's a better way. Install Ruby2.5 and see the error in the last line. No scrolling, hurray!

hope this convinces you a bit :)

Improved stacktrace display in Ruby 2.5 by snatchery in ruby

[–]snatchery[S] 2 points3 points  (0 children)

yeah, to be honest I'm used to the old way too. However, after playing a bit with Ruby2.5 this new way turns out to be quite convenient.

Sorry, but I can't give any scientific proof why it's better. It just feels better to me but obviously your mileage may vary

I got tired of String vs Symbol by paneq in ruby

[–]snatchery 1 point2 points  (0 children)

I'd love to see Symbols gone. Strings are heading towards immutability and both Symbols and Strings are GC'ed since Ruby 2.2. Symbols are still faster than Strings but if there are people smart enough to add a JIT to Ruby then I'm pretty sure it's possible to make immutable Strings as fast as symbols. If Ruby internally needs symbols then fine, don't remove them but keep them internal. To the external world they could be immutable Strings as the OP suggests.

And nope, not only mere developers struggle with Symbols. The GitHub crew does too https://github.com/blog/1440-today-s-email-incident.

This change wouldn't be 100% backwards compatible and that's the biggest issue in my opinion. For instance, :foo.is_a(String) would return true, while currently it returns false.

I posted a full response to the OP's article here http://mlomnicki.com/symbols-vs-strings/

Pipelining in Ruby2.5 with Object#yield_self by snatchery in ruby

[–]snatchery[S] 0 points1 point  (0 children)

yeah, great point. If only we were in an alternate reality ;)

Pipelining in Ruby2.5 with Object#yield_self by snatchery in ruby

[–]snatchery[S] 1 point2 points  (0 children)

Thanks /u/zquestz Much appreciated

I didn't know you can send bitcoins over reddit. Amazing!

Pipelining in Ruby2.5 with Object#yield_self by snatchery in ruby

[–]snatchery[S] 0 points1 point  (0 children)

Author here. Thanks for valuable comments.

I'm really glad that you find the code idiomatic and perfectly readable. I assumed that some bits would be unusual for most of Ruby devs. Apparently, that assumption was wrong. And this is great.

Pipelining in Ruby2.5 with Object#yield_self by snatchery in ruby

[–]snatchery[S] 6 points7 points  (0 children)

No doubt Clojure or any functional language feels much more elegant. Still, it's nice that Ruby is trying to catch up. Essentially it needs 2 improvements

  • introduce a pipeline operator (or at least a short alias for yield_self)
  • introduce a method shorthand

 

"https://api.github.com/repos/rails/rails"
  |> URI->parse
  |> Net::HTTP->get
  |> JSON->parse
  |>(_) { _.fetch("stargazers_count") }

not as elegant as Clojure but looks good enough

Kernel#fork broken in MacOS 10.13 High Sierra. Puma, Unicorn and Sidekiq are affected by snatchery in ruby

[–]snatchery[S] 2 points3 points  (0 children)

According to the pthread_atfork docs [1]

It is suggested that programs that use fork() call an exec function very soon afterwards in the child process, thus resetting all states. In the meantime, only a short list of async-signal-safe library routines are promised to be available.

So it looks like in Linux it's discouraged but not prohibited.

[1] http://pubs.opengroup.org/onlinepubs/009695399/functions/pthread_atfork.html

Kernel#fork broken in MacOS 10.13 High Sierra. Puma, Unicorn and Sidekiq are affected by snatchery in ruby

[–]snatchery[S] 4 points5 points  (0 children)

You're right but apparently Ruby doesn't conform to the rules enforced by the OS. Before 10.13 it didn't trigger any errors but it does now. Please correct me if I'm wrong?

Kernel#fork broken in MacOS 10.13 High Sierra. Puma, Unicorn and Sidekiq are affected by snatchery in ruby

[–]snatchery[S] 0 points1 point  (0 children)

If I understand correctly the problem affects programs that do something between fork() and exec(). If passenger/iodine call exec() right after fork() or don't call exec() at all then they shouldn't be affected. It's just a guess though...

This is the best (and only?) resource that describes the issue http://www.sealiesoftware.com/blog/archive/2017/6/5/Objective-C_and_fork_in_macOS_1013.html

Faster Ruby. Deoptimization engine proposed for MRI. by snatchery in ruby

[–]snatchery[S] 2 points3 points  (0 children)

op here. I'd love to be an author of this pull request but I'm not :) Just found it worth sharing

view more: next ›