Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Ruby 2.5.0 Released

ruby-lang.org

Post reply on HN
Print view View original

91–100 of 113 posts

Re: Ruby 2.5.0 Released

#91

Post by stouset »

dmitriid wrote: post #85
nfm wrote: post #80

Earlier quoted context omitted.

Not really. It's hard for your editor to do this statically, but there's heaps of good tooling for finding the method source and docs dynamically. pry> show-source SomeClass.class_method pry> show-source AnotherClass#instance_method # List an arbitrary object's class methods, instance methods, methods mixed in by included modules pry> cd some_object pry> ls The runtime knows how to execute your program (it's not rand…

You realise you just validated my point, right? :)

I'm not sure you did.

People who don't use Ruby seem to think this is a huge thing that you run into constantly. It's not. People are for the most part pretty responsible with these things.

Re: Ruby 2.5.0 Released

#92

Post by vemv »

eropple wrote: post #51
pankajdoharey wrote: post #12

i loved ruby and i still do but my focus has now shifted to scheme/clojure and lisp family dialects like racket, and i don’t see a reason to return or move to anything else it feels like my search is over.

If your "search is over", you're doing it wrong. Something sucks about everything you are using, no matter what it is. There is a better thing, even if you must make it.

Would agree with your view, but Lisps are arbitrarily powerful by the means of macros and interop.

In my daily work (Clojure) I can use different concurrency and typing models than Clojure originally envisioned, via core.async, clojure.spec. This is not some fairy tale or toy/PLT project.

How many languages can fundamentally change themselves without breaking things or getting awkward?

Re: Ruby 2.5.0 Released

#93

Post by inopinatus »

dmitriid wrote: post #78
stouset wrote: post #31

Earlier quoted context omitted.

Disagree 1000%. Just because you can write a monstrosity in Ruby doesn’t make the language itself inelegant. Ruby, of the many languages I’ve used, has by far the highest potential for code being poetry. You can find solutions that are incredibly simple and understandable due to so much boilerplate being remove from the syntax. Likewise you can write code that’s impressively concise without being inscrutable — I’m co…

> Sure, these depended upon injecting new methods into core classes, but who cares? I, as a developer reading your code 6 months later, care. When something fails, it's nearly impossible which of the magic methods were injected by which magic library.

It’s very far from impossible. It is trivial to programmatically determine where a method was defined using Method#source_location.

Determining which method responds to which message is only possible in an instantiated runtime, but that’s true for any late-binding programming environment. Complaining about it tells us more about the complainer than about the language.

Re: Ruby 2.5.0 Released

#94

Post by drchiu »

Love Ruby. Back a few years ago before I learned to program properly, I found a lot of the syntax of various languages to be hard to understand. I was not trained as a computer science major, mind you. Nonetheless, the syntax of the Ruby language made things easy enough for me to digest. Heck, even ended up starting a Ruby based software company won’t employees — something I couldn’t have imagined doing even a decade ago.

Re: Ruby 2.5.0 Released

#95

Post by onetwotree »

Hey they finally fixed the issue with SecureRandom using OpenSSL instead of the OS CSPRNG implementation!

I worked for a company a few years ago that made security software, with Ruby as a primary language, and this caused no end of frustration...

Re: Ruby 2.5.0 Released

#96

Post by eropple »

vemv wrote: post #92
eropple wrote: post #51

Earlier quoted context omitted.

If your "search is over", you're doing it wrong. Something sucks about everything you are using, no matter what it is. There is a better thing, even if you must make it.

Would agree with your view, but Lisps are arbitrarily powerful by the means of macros and interop. In my daily work (Clojure) I can use different concurrency and typing models than Clojure originally envisioned, via core.async, clojure.spec. This is not some fairy tale or toy/PLT project. How many languages can fundamentally change themselves without breaking things or getting awkward?

Lisps are arbitrarily powerful, yes, sure. Once I too was a Lisp head, I am familiar with the advocacy.

They also read awfully even with an editor designed for them. They aren't human-first languages. S-expressions are easy for a computer, they are hard for a human. So, yeah, that can be improved, too. "But you can do it with macros"--other people won't, and so you are thus devolved to the minimum set everyone can agree upon, and it's gonna be awful.

And so there is room to grow outside of one's parentheses, too.

Re: Ruby 2.5.0 Released

#98

Post by flavio81 »

vemv wrote: post #92
eropple wrote: post #51

Earlier quoted context omitted.

If your "search is over", you're doing it wrong. Something sucks about everything you are using, no matter what it is. There is a better thing, even if you must make it.

Would agree with your view, but Lisps are arbitrarily powerful by the means of macros and interop. In my daily work (Clojure) I can use different concurrency and typing models than Clojure originally envisioned, via core.async, clojure.spec. This is not some fairy tale or toy/PLT project. How many languages can fundamentally change themselves without breaking things or getting awkward?

>Lisps are arbitrarily powerful by the means of macros.

This is my experiencie too. S-expressions + macros is an amazingly powerful combination.

Re: Ruby 2.5.0 Released

#99

Post by flavio81 »

eropple wrote: post #96
vemv wrote: post #92

Earlier quoted context omitted.

Would agree with your view, but Lisps are arbitrarily powerful by the means of macros and interop. In my daily work (Clojure) I can use different concurrency and typing models than Clojure originally envisioned, via core.async, clojure.spec. This is not some fairy tale or toy/PLT project. How many languages can fundamentally change themselves without breaking things or getting awkward?

Lisps are arbitrarily powerful, yes, sure. Once I too was a Lisp head, I am familiar with the advocacy. They also read awfully even with an editor designed for them. They aren't human-first languages. S-expressions are easy for a computer , they are hard for a human . So, yeah, that can be improved, too. "But you can do it with macros"--other people won't , and so you are thus devolved to the minimum set everyone can…

>They aren't human-first languages. S-expressions are easy for a computer, they are hard for a human.

I've used Python, C, C++, C#, Java and Pascal extensively. I can safely say Common Lisp allows you to write the most readable code of all languages i've used, and i'd expect this to be the same for most other lisps.

Since they are hugely flexible, they allow you to write code in such a way that the problem and solution are expressed in the most explicit and straightforward way.

Re: Ruby 2.5.0 Released

#100

Post by JohnBooty »

nfm wrote: post #80
dmitriid wrote: post #78

Earlier quoted context omitted.

> Sure, these depended upon injecting new methods into core classes, but who cares? I, as a developer reading your code 6 months later, care. When something fails, it's nearly impossible which of the magic methods were injected by which magic library.

Not really. It's hard for your editor to do this statically, but there's heaps of good tooling for finding the method source and docs dynamically. pry> show-source SomeClass.class_method pry> show-source AnotherClass#instance_method # List an arbitrary object's class methods, instance methods, methods mixed in by included modules pry> cd some_object pry> ls The runtime knows how to execute your program (it's not rand…

Been doing Ruby full-time for 3+ years, bunch of experience before that.

    there's heaps of good tooling for finding the 
    method source and docs dynamically
I know, but this is a huge problem with a lot of code I see in the wild because this stuff is (ab)used so widely in Ruby-land.

If I have to run code just to see where `Foo.bar` is defined, that makes things... about an order of magnitude harder to understand. I mean, that's really tough thing to do in anything but a trivial codebase.

This is nearly 100% the fault of developers, not the language itself, but I would suspect that most Ruby developers spend a significant amount of time dealing with things like this because it's how the ecosystem rolls.

Post reply on HN