

Try Ruby (in your browser, now with 1.9) - jmonegro
http://tryruby.org/

======
patio11
_why's version of this site was my first exposure to Ruby. I was a convert
(from Java) as soon as I got to map.

%w{apple pear banana}.map {|f| puts "#{f} is a fruit."}

This experience shows one of the fundamental truths of software marketing,
incidentally: anything you can do to reduce the barriers to trying the
software out increases uptake _dramatically_. Eliminating the install is
powerful, powerful stuff.

~~~
axod
It was useful for me in an opposite way :)

It showed me why I hate Ruby syntax. The above just looks horribly ugly. A
mishmash of special characters. Not to mention special characters in _strings_
(eugh).

The probability of an undetectable typo in the code you paste is pretty high.

Sure, it's not quite up there with regexp syntax, but it's getting close.

~~~
Pistos2
FWIW, I've been coding Ruby going on 7 years now (well over 100,000 lines of
Ruby across all projects, I'd wager), and my memory estimates fewer than 5
instances of "undetectable typo". Generally, the typos I made and tried to run
produced very obvious, visible and traceable symptoms (i.e. a precise and
accurate stack trace).

I was asked in an interview once (by a skeptic that didn't know Ruby) if it
weren't a problem that mistyping a variable name could produce a bug that
would be difficult to detect and debug. I informed him that, in practice, it
is essentially a non-issue.

There are two aspects of Ruby (among others, I'm sure) that help protect
against the sort of hidden bugs you're worried about:

1) You cannot reference a variable that has not been defined yet. Example:

    
    
        % ruby
        supercalifragilisticexpialidocious = "something quite attrocious"
        puts "I'm thinking of #{supercalifragilisticexpialodocious}."
        ^D
        -:2: undefined local variable or method `supercalifragilisticexpialodocious' for main:Object (NameError)
    

2) Ruby will not silently or automatically convert or cast data types. (Where
it seems to do so, in actual fact underlying library code is explicitly
calling the conversion methods (#to_s, #to_i, #to_f, etc.)) Example:

    
    
        % ruby
        count_str = "8"
        count = count_str.to_i
        puts count < 9
        puts count_str < 9
        ^D
        true
        -:4:in `<': comparison of String with 9 failed (ArgumentError)
    

Contrast that with, say, Perl:

    
    
        % perl
        use strict;
        my $count_str = "8";
        my $count = 0 + $count_str;
        print $count < 9; print "\n";
        print $count_str < 9; print "\n";
        ^D
        1
        1
    

Combine all of the above with good testing practices, and your bugs turn out
to be quite detectable on the whole.

~~~
axod
It's not just about potential bugs though. It's readability, maintainability
etc. For me, the original code pasted is horrible in terms of readability.
Sure, it's concise, but it's lots of small characters that you could misread
etc.

~~~
jamesbritt
"Sure, it's concise, but it's lots of small characters that you could misread
etc."

To each his own, but have you spent much time coding Ruby and encountering
this problem?

I ask because it's not a problem I've had or hear from people who have been
using the language. It seems to be be an issue expected by people who have not
yet spent much time using Ruby (much like concerns over the lack of static
typing).

From a distance it may seems as though things would get confusing, but in
actual practice this seems not to be the case.

Could be a selection bias, but I would like to hear from people who have truly
used Ruby in earnest and stopped because of repeated annoyances.

------
city41
Not being able to backspace (at least on my MacBook with 10.6) is a deal
breaker here. As much as I'd like to be, I'm not a perfect typist.

~~~
rudd
Backspace works here on my 10.6 Macbook in both Safari and Firefox. Though,
Command-w to close it doesn't work for me.

~~~
noisebleed
Yeah, for whatever reason the command key doesn't register on the page

~~~
city41
The javascript key handlers are absorbing them. Outlook Web Access does this
too (and it drives me crazy there).

------
spicyj
I've got to admit that the 1.9 sticker and the "BETA" text don't really blend
in with the existing look of the site.

~~~
nym
Yeah, too many fonts.

------
aarongough
Clever! But in all honesty, I was a little disappointed when I discovered that
Ruby was not being emulated in JavaScript or something similar. Just bouncing
the entered text back to a server-side instance of IRB instead...

~~~
mpk
Well, an official spec for Ruby is in the works and there's already one for
JavaScript (ECMAScript). Someone is bound to build a Ruby VM in JS at some
point and then it'll be trivial to build a site like this.

The performance will be horrible, of course, but once that happens some other
person will come along and run a subset of Rails (or some other Ruby web
framework) with an evented db backend on it (for async callbacks to the server
over HTTP) to run an app in the browser.

Which would be pretty cool, though not useful. (But don't let that stop you,
whoever you are!)

~~~
ThinkWriteMute
I believe a Ruby VM is already in the works, but my cold addled brain can't
google fu right now.

~~~
Zev
That would be HotRuby, <http://hotruby.yukoba.jp>.

------
ThinkWriteMute
Interface acts odd on Debian+Webkit+Chrome4.

------
jmtame
way too slow.. i'd rather just fire up irb

~~~
stevejohnson
That is not the point AT ALL. This isn't about knocking out one-off scripts to
do useful things, it's about trying out the language to see if it's worth
installing at all.

_why the lucky stiff did a lot for Ruby evangelism. This site combined with
the Poignant Guide turned a lot of curious folks into converts.

I know this stuff despite being a Python fanatic. I have great respect for
what _why did for the Ruby and programming communities in general.

------
hbrundage
I read somewhere that the problem of "syntax design", that is choosing how a
language requires you to write it, is regarded as "solved", that is we don't
need any more constructs or abilities in languages. Whoever it was said that
the real problems remaining are speed and size and the other stuff.

I agree that this is the case, but only because Ruby exists. If you haven't
tried it then really, please do, I think you'll like it.

~~~
prodigal_erik
Language design isn't a solved problem until we have a language that enables
the average programmer to add any syntax they need. Lisp only comes close by
punting and rubbing everyone's nose in the raw parse tree, and the average
programmer ritually shuns it anyway.

Ruby doesn't even attempt to solve this problem. You can tell because if it
didn't already have try/catch or begin/rescue or case/when, adding them
yourself would be impossible.

