
A first naïve look at Truffle Ruby - thibaut_barrere
https://github.com/oracle/truffleruby/issues/1054
======
vertis
It's a bit sad that my first reaction is to go, "oh it's Oracle" and then look
at the license.

It's GPL LGPL and Eclipse, which is convoluted but otherwise uninteresting.

~~~
chrisseaton
It's GPL or LGPL or Eclipse. You can pick whichever you want - it's not a
convolution of all three. The licence comes from JRuby, which we forked from.

------
news_to_me
I hadn't heard of Truffle Ruby before now — it looks pretty awesome. My
experience with ruby has so far been limited, but as much as I've used it, I
don't really see any downsides to the language except speed (for web
applications, anyway).

~~~
iagooar
Things I dislike the most about Ruby:

\- Raw performance

\- Runtime metaprogramming from hell

\- Monkey patching

\- No real concurrency support, tons of non-threadsafe code and gems

\- Too Rails-centric

\- Little presence outside web development

\- Little to no real innovation in the last years

\- Mutability

\- No optional / progressive types or type annotations

===

Things I love about Ruby:

\- Clean syntax

\- Although it's object oriented, it allows using a functional style

\- Functional collection operations

\- Productivity

\- Flexibility

\- Maturity

\- Availability of high-quality libraries

\- Availability of hosting solutions

\- Friendly community

\- Nice stack traces

~~~
tomc1985
> \- Little to no real innovation in the last years

You are sooooooooooo wrong it isn't even funny. I'm stuck coding to Ruby 2.2
and Ruby 2.5 is looking more and more like a totally different world.

> \- Mutability

Never understood this complaint from people. I just recently started playing
with a language that supports immutability (Kotlin) and it is weird to me that
you guys seem to be asking for constants, rebranded. Even weirder is if I
write my vars' names in CONSTANT_CASE I get yelled at by the code formatter!

Plus, in immutable languages, are there cases where immutability extends to
nonscalar values like arrays or hashes or objects? That distinction just feels
so...arbitrary.

Is data changing that big of a problem?

~~~
thedufer
> Is data changing that big of a problem?

Yes, but it is hard to recognize it as such until you've experienced the
alternative.

I don't know much about Kotlin, but the fact that it relies heavily on Java
libraries is sufficient to tell me that it is a particularly poor example of
the power of immutability. You see the usefulness of immutability when you
have objects that are deeply immutable - when you pass them around, you know
those functions haven't changed them. It is much easier to reason about deeply
immutable objects than mutable ones.

> in immutable languages, are there cases where immutability extends to
> nonscalar values like arrays or hashes or objects

Yes, this is largely the point. Although, you will rarely see an immutable
array or hashtable - more likely it will be a linked list or balanced binary
search tree.

~~~
nine_k
Kotlin runs on JVM but it's closer.to Scala, not Java. You can sure have
immutable structures all the way down in it, as if it were Haskell. It doesn't
enforce this style, though.

------
grover_hartmann
It always bothered me that Ruby isn't used as much as Python is used outside
of web development.

I think Ruby is a nicer language than Python is in many ways.

~~~
busterarm
Lots of operations code was written in Ruby. Just look at Chef, Capistrano and
Puppet.

That whole field wants to be Google though and thinks they have Google's
problems, so now it's mostly all Python and Go. HashiCorp has written some
great stuff at least.

~~~
dictum
> That whole field wants to be Google though and thinks they have Google's
> problems

It's becoming a recurring phenonemon, isn't it? I feel the same with frontend
web development: everyone wants to be Facebook.

~~~
busterarm
preaching to the f'ing choir here mate.

The volume of material out there written to help people improve the
performance of their React applications makes it pretty clear to me that folks
aren't looking before they leap.

I've seen more than a couple dozen projects with ~20-40 lines of simple,
performant, vanilla JS turn into multi-hundred line behemoths + _an entire
React framework_ for exactly zero benefit to end users because of "best
practices".

