Ruby User Statistics

Every now and then, new Ruby users are invited to complete a survey form. This page uses a Ruby script ('natch) to summarize what people told us.

Total number of responses:
554 , from Sat Dec 23 21:23:50 EST 2000 to Mon Aug 04 02:17:22 EDT 2003
What are people using Ruby for:
311 Just experimenting
318 General scripting
137 Web development
147 Application prototyping
192 Application development
  • Other uses:
  • Programming language research
  • bioinformatics development
  • embedded scripting language in C++ programs
  • hosting
  • learning OOP
  • scripting our staff planning system
  • nifty command-line hacks
  • library for Ruby
  • final senior project (AI) for computer science degree
  • Replace legacy ANSI C (no GUI)
  • replacement for perl
  • test environments
  • what we used to call "hacking" :-)
  • text maniplation
  • Pattern prototyping and Arhcitecture prototyping
  • build system
  • Jabber enabled applications
  • Testing Using the IE DOM
  • Analysis
  • for fun
  • Automated software testing (not XP's "testing")
  • database
  • Learning true OO development.
  • exploring object oriented concepts
  • systems administration
  • scientific computing
  • embedded into c++
  • Evaluation: Using it in teaching computer science
  • tool development
  • The Pragmatic Programmer
  • Extension building using SWIG as interface
  • learning OOP
  • Testing
  • Play
  • Virtual environment scripting
  • mostly c++ code beautification, and general scripting
  • data analysis/management tools
  • scripting language for standard product
  • Algorithm experimenting and learning OOP
  • GUI development
  • GUI interfaces
  • Genetic Programming
  • automated agents/bots
  • Having fun
  • language development
  • learn OO
  • thinking about EDI/FEDI stuff. (bank recon and positive pay)
  • develop win32 extensions
  • teaching
  • I'm planning to use it for Application prototyping/development, but I don't know enough about Ruby yet
How long have people been using Ruby:
49 Never used Ruby
202 < one month
111 one to three months
44 three to six months
46 six to twelve months
49 > twelve months
How did people hear about Ruby:
74 Friend/colleague
211 Article on the web
17 XP mailing list
8 Ruby newsgroup/ml
57 Dr. Dobbs article
  • Other ways:
  • article in the german paper magazin IX
  • german c't magazine
  • Mentioned on Amiga, Phoenix Consortium mailing lists
  • The gentoo linux forums
  • ct - popular german computer magazine
  • Andy/Dave presentation at JAOO'00, Denmark
  • Saw books on it in the bookstore
  • work
  • Included in RedHat distribution
  • The Pragmatic Programmer book
  • I was looking for the language to replace Perl
  • "Pragmatic Programmer" book
  • from reading the pragmatic programmers book
  • Book: 'Produktiver Programmieren
  • bsd ports
  • Book: 'Produktiver Programmieren'
  • Heard of it and got curious
  • pick-axe book
  • mostly Dave Thomas book
  • O'Reilly
  • usenet
  • pragmatic prog
  • loaded on my system for portsupgrade
  • Javaworld
  • Linux Journal Article
  • pragmatic programmers at jaoo
  • newspaper article
  • Can't recall exactly, I was drunk at the time I found the ruby-lang site.
  • Linux Journal
  • Developer.com Update
  • Bookstore and Google Directory
  • Browsing Usenet groups of the comp.* hierarchy.
  • comp.lang.misc
  • A Japanese magazine
  • The Pragmatic Programmers
  • Following the next title from the authors of Pragmatic Programmer
  • Linux's Magazines
  • Linkwww.cetus-links.org
  • Saw the pick axe book at Borders
  • I created it
  • "Programming Ruby"
  • Linux Magazine (UK)
  • Read Dave & Andy's "Pragmatic Programmer"-Tip: Learn a new language each year
  • from my boss
  • linux apps listing
  • some other newsgroup
  • some small, but important comments on python-USENET-group made me take a look... I knew about Dave Thomas from the XP-list and then I was marked for good after reading about ruby at www.pragmaticprogrammers.com
  • Saw the book
  • pragmatic programmers
  • amazon book browsing!
  • Saw it in Cameron Laird's UnixInsider scripting column, but got interested because of the Dr. Dobb's article and bought the Thomas/Hunt book
  • comp.lang.python
  • Linux distro
  • Pragmatic Programmers
  • OOPSPLA 2000
  • Article in a magazine
  • www.pragmaticprogrammer.com
  • freshmeat announcement
  • Linux Journal
  • debian-devel
  • questions@freebsd.org mailing list
  • The Babel Language Design Community http://tos.maintree.com/babel/
  • Pragmatic Programmers
  • news:comp.software.extreme-programming
  • FOX mailing list
  • Tech TV I think
  • various
  • FOX GUI mailing list
  • Slashdot
  • Pickaxe Book
  • Squeak and XP Mailing list and friend, just couldn't ignore it anymore.
  • Usenet
  • Linux Magazine
  • I found it in /usr/bin/ruby :-) with Linux-Mandrake
  • FreeBSD cvs commits
  • URL in a /. comment
  • discussion on comp.lang.python
  • Class Extra Credit
  • Linux Magazine
  • comp.lang.python
  • Apr '03 Software Development article
  • Programming Ruby Book
  • found in Yahoo
  • pragmathic programmers
  • Usenet
  • article in magazine iX (Germany)
  • freshmeat.net
  • don't remember
  • from my dad
  • comp.lang.smalltalk newsgroup
  • JAOO conference
  • extropian mailing list
  • Linux Journal article
  • Perl Monks
  • Pragmatic Programmer
  • professor
  • "The Pragmatic Programmer" from Dave & Andy
  • google
  • webinfo and magazine articles
  • Yahoo language category
  • Other newsgroup
  • O'Reilly web site
  • Book
  • iX (German computer magazin) article
  • The Pragmatic Programmer
  • irc (knu)
  • PC Magazine
  • Webforum
  • Noticed the number of FreeBSD Ports for it.
  • Article on ix (german magazine information technology)
  • by accident
  • by accident
  • newspaper
  • lurking the web
  • JavaHouse ML
  • Initial Import of Ruby to the NetBSD (pkgsrc) Packages Collection
  • Slashdot
  • sourceforge.net
  • article in IX
  • Linux Magazine article
  • newsgroup
  • www.cetus-links.org
  • www.python.com
  • a posting on comp.lang.python
  • Pragmatic Programmer
  • comp.lang.eiffel
  • /. link to ibm developerworks article by Maya Stodte (mstodte@pop.rcn.com)
  • pragmaticprogrammers.com
  • FOX GUI Toolkit mailing list
  • freebsd-ports tree (lots of ruby entries)
  • included in a Linux distro
  • It was included in the RedHat 7.1 Linux distribution
  • mentioned in a posting to comp.object, I believe
What operating systems are you using:
13 AIX
9 HP-UX
326 Linux
35 Mac (OSX)
51 Other Unix
73 Solaris
168 Windows 2000
20 Windows 95
103 Windows 98
37 Windows ME
92 Windows NT
  • Others:
  • Windows XP
  • Windows XP
  • BeOS, FreeBSD!!!
  • FreeBSD
  • Windows XP
  • freebsd
  • FreeBSD
  • Windows XP
  • openbsd
  • Windows XP
  • Windows XP
  • winXP
  • OpenBSD / NetBSD
  • Windows XP
  • SPARC SUN-OS4
  • Windows XP
  • SGI Irix, FreeBSD
  • OS/2
  • Windows XP
  • FreeBSD
  • WinXP
  • How about OpenVMS?
  • OpenBSD
  • FreeBSD
  • BeOS
  • XP Pro
  • Windows XP
  • XP
  • Windows XP
  • Windows XP
  • FreeBSD
  • T64U
  • FreeBSD
  • WINDOWS XP
  • Windows XP
  • FreeBSD
  • Freebsd/netbsd
  • BeOS
  • BSD Unix
  • FreeBSD
  • WinXP
  • FreeBSD
  • freebsd5
  • If I go into production, it will either be Linux or NT
  • SGI Irix, FreeBSD
  • BeOS
  • FreeBSD
  • EPOC
  • FreeBSD
  • Windowx XP
  • IRIX
  • FreeBSD
  • BeOS
  • Windows XP
  • OpenBSD
  • Windows XP
  • Win XP
  • NetBSD / OpenBSD
  • Windows XP
  • FreeBSD
  • Windows XP
  • Windows XP, FreeBSD
  • FreeBSD
  • FreeBSD 4.8
  • Win XP
  • FreeBSD
  • Windows XP
  • OSF1 V4.0 1229 alpha
  • FreeBSD
  • FreeBSD
  • FreeBSD
  • FreeBSD
  • FreeBSD
  • Windows XP
  • Windows XP
  • Windows XP
  • Windows XP
  • FreeBSD
  • windows XP
  • cygwin
  • OpenBSD
  • FreeBSD 4.X-STABLE
Things people would like to see added to Ruby:
  • Standardized packages/libraries. A huge standardized (the same set in each distribution/port/same version; no standards commitee for the language; just aset of requirements for the library) set of packages/libraries could be the only chance for Ruby to gain massive poularity.
  • 1- a more robust windows implementation (the current one has many bugs including a system command which does not understand
    correctly redirections pipes etc ) and misses many useful extensions
    (e.g. curses). Ruby should try to emulate the quality of activestate
    perl implementations.
    2- it is time to re-think the library. Many methods in classes should be pushed to mixins (cf. eg. matju's work on arraymixin).
    3- The basic data structures mimic perl. This could be improved:
    I think the basic choices in lua and php are slightly better with the benefit of hindsight. But at this stage it is probably too late to change the language in such a way.
    4- If the concept of overloading methods by argument types could be added to the language in an elegant way, it would be a good addition.
  • not really sure
  • cpan for ruby
  • A good cross-platform IDE (I considering developing one for Ruby).
  • -Clearer organization of news/documentation sites
    What is Ruby-Lang vs. RubyCentral vs.
    RubyGarden?
    -Improved newbie documentation (pointer to an
    intro to OO terminology, please!)
    -Self-documenting [classes?|objects?], sound
    neat.
  • More libraries, specially GUI related stuff.
  • More documentation and examples for beginners.
    A complete module for using SNMP so I don't have to use Perl for it.
  • Better documentation.
  • - good IDE
    - DBI in standard distribution (and better DB drivers
    - more and better docs (english, maybe in german)
    - better support for Apache2 (modruby/eruby)
  • Standardized, stable, and complete cross-platform GUI framework. A Ruby archive network (with more applications than the RAA today).
  • More libraries (CPAN is just sooooo useful)
  • Maturity, more classes...
  • Consistency across distributions in terms of what is supported, both in the language foundation and the libraries-- e.g., zlib was included in 1.6.5 cygwin, but not in 1.6.6 mswin (the PragProg distro).
    And a set of libraries as extensive as Python's would be outstanding!
  • A nice standard GUI (wxRuby?)
  • Easier bindings into C++. Obviously, I can do C bindings, then wrap them in C++ objects. But Ruby has OBJECTS and C++ has OBJECTS. It makes more sense to be able to bind those together than it currently does with C (where you bind an OBJECT to a bunch of procedural functions.)
  • Ruby written in Ruby.
  • Japanese documentation in English
  • More libraries. More efficient execution would be nice, but it is far from paramount.
  • Bigger RAA.
  • More maturity, ie, many gui's and libraries are evolving rapidly but aren't ready for consumption yet. ie, Python is (appears to me, a non user) to have more applications and libraries for it.
  • More libraries. A CPAN-like utility/web-site. More books on interactive use of Ruby. A great IDE for Ruby. A daily news site like:
    http://www.pythonware.com/daily/
  • Better available Web integration (i.e. not having to write session variable classes myself, etc.) It would be super-cool if I could just replace all the PHP I have to write with Ruby. But there are many things that are just way easier to do in PHP, because of its built in functionality. I don't like Ruby's CGI class--it seems to make everything kind of cluttered, which is unlike all else in Ruby.
  • built in audio, midi functions
  • If I had more gray matter, Ruby would be more useful to me.
  • not enough experience to make suggestions
  • I want it to become popular enough that people don't go "Huh? What's Ruby?"
  • a coherent explanation of 3rd party tools, such as PRECISELY what %Q(require 'gtk') means; i.e., WHICH gtk are people referring to?
    ruby "reflection" leaves a lot to be desired, as the proliferation of things like ri, rdtool, etc. might indicate -- especially for programmers used to IDEs that link to complete documentation when one command-clicks a class name or method -- maybe a Ruby IDE, then? Seems like overkill, but in practice, maybe not :-)
  • how to use ruby in windows, statements that create forms inputng data and adding data to files(db) and presenting data back to the windows form.
  • Documentation, organized like man pages or, at least, perldoc; it's really annoying that I cannot just to say 'man FXFileDialog' to see parameters, description, synopsis, short examples, see also...
  • method dispatching by parameters (and maybe return value) classes. class variables for one class (and not for hierarchy).
  • Examples: cookbook-style, Perl-way vs. Ruby-way.
  • more modules.
  • Speed, speed, speed!
    An IDE, with syntax highlighting, debug capability, etc.
  • A brain upgrade (for me).
    Descriptions of the purpose of each module next to the names of each module in the RAA
    Splitting the ruby mailing list into two - one list for people who want to *change* ruby and another for 'meat and potatoes' programmers like me who just want to use the latest stable version. Takes too long to go through the current list!
  • Cleanup of the Library space, name-space wise as well as the listings. CPAN is really a great example
  • Engilsh Documentation, More Modules,libraries
  • A converter ruby to c or something like the freeze utility in python.
    An idle like in python. irb is great but I find that idle nicer.
    Such a big bunch of libraries that python has
  • can compile x86 fast :) dreams...
  • IDE provided with distribution
  • High-performance regular expressions, embedding capabilities (i.e. no exit() on exception, etc.).
  • The command-line feature and the web integration (or eruby).
  • Right now, I couldn't say
  • a good rb2exe compiler. more books and documentation about specific topics (like e.g. "Perl & LWP"). being able to use ruby (instead of perl) to write CGI scripts on e.g. tripod homepages.
  • I like it just as it is right now. Any further improvement in speed would be great though.
  • better web classes: cgi and cgi/session need some work.
  • better entry documentation. Annotated 'real' project
  • If all modules in development out there would contain English documentation.
    a more detailed English tutorial.
  • Something like CPAN for RUBY ( I dont mind writing one with help frm u ppl ) some one should write something like perldoc so u can do rubydoc <Module Name>
  • Easier way to install modules under Win32.
  • A mode for syntax highlighting in Glimmer.
    A larger selection of programs to learn from.
  • Mature extensions easily available for
    * DBI database access
    * Easy packaging of applications (Something like Java's JAR file format)
  • SNMP, Telnet support modules/classes
    X debugger
  • More and better English documentation, CPAN, '
  • Clean syntax. Not just readable, but _clean_. That's a rare, valuable trait.
  • I would eventually like an archive of modules/classes that rivals the CPAN, and I'm quite willing to participate.
  • wxruby
    better windows integration
    nntp
  • English documentation ! :-) Seriously, a great deal of good work has already been done, but I'm frequently lost. I think the Python documentation is extremely well done, for instance.
  • Bytecode compiler/interpreter
  • 1. A facility similar to Perl's Inline so that Perl code could be
    called from ruby (so legacy code can be used)
    2. RAA to be as well developed as Perl's CPAN
    3. More English Documentation (actually, this should be #1)
  • I've already been burned by "elsif". From a human factors perspective, it would be much better if it were "elsEif" (lower case, of course).
  • Better English language documentation. The irc channel os very helpful, but is a poor substitute for good docs. Particularly I have had trouble finding more about iterators, and closures. And coming from Java/C++ those are new ideas to me. Both Java and C++ have iterators, but not in the same sense as Ruby.
  • Better and more documentation.
    CRAN
  • Ruby/Tk reference materials. Better XML support, something along the lines of JDOM.
  • More and better English documentation;
    Built-in GUI or at lest an official GUI toolkit;
    A compiler for Ruby;
    Database access
  • 1) support/help/tutorials for compiling extensions on windows using a free compiler
    2) more Tutorials and commented Sample Scripts
  • Expanding RAA as much as possible. Surpass CPAN :P
  • ability to write extensions in java...
  • Better embedding into C/C++ programs. Or, if it does this really well already, then a tutorial or something considerably more in depth than the pickaxe book has. Also, Please No Exits In The Ruby Code! This makes it very hard to work with and is not a substitute for error handling! I'd like to use Ruby as a static library, but I don't want to link to a library with exits in it!
  • More speed, type checking
  • A powerful IDE, a Semantics-File for Emacs ECB, a wxWindows binding
  • I hesitate to say it because I don't think it is really that bad, but a little more documentation would go a long way.
  • bioruby
    i would like to use ruby in bioinformatics field like biojava or bioperl or biopython
  • Easier support for binding to C++, esp. with regards to exception safety and the jungle of virtual function invocations.
  • Better GUI tools for Windows. Not a fan of GTK, and couldn't be bothered wrapping anything myself in the short term. This is, however, a luxury, rather than a requirement.
  • Well documented way of doing GUI programming with a toolkit such as gtk+.
    Perl has CPAN, I wish Ruby had something similar with all of that functionality---of course, this will take us some time to build!
  • More speed, type checking
    wxwindows port
  • Just the standard things: more libraries, a complete IDE, more (and more complete) documentation in English.
  • An excellent book on Ruby for beginners to Ruby who already can program in another language.
  • don't know yet.
  • Native threading and integrated (into the core language) support for XML. (none of these six packages to choose from)
  • a feature to directly map a file-format to an object
    a better integrated GUI
    IDE!!!!!!
  • ISO-8859 (Latin) support
    Unicode
    TinyRuby (subset enginge to use as an embeddable scripting language in larger programs/systems), preferrably useable on 16-bit DOS architecture)
    IDE for Linux and Win32 (less important) with Intellisense-like technology and good online docs that can be called up from within the dev env
  • Extended scheduler (Not plain old stupid select() only!)
    Real (preemptive) Multitasking.
  • GUI Builder IDE
  • Better support for GUI applications. Double-precision floats?
  • built-in GUI (xml-svg?) NOT Tcl/Tk
  • More documentation, esp. on creating GUIs. Also, an IDE would be nice.
  • A decent IDE for the Windows platform (shame on me).
  • A paying job which used Ruby as the primary development language :). Seriously, although I use Ruby at work for scripting, I don't get a lot of opportunities to really apply the language. I've done some application development at home using Ruby, but have very little time for it :(.
  • A Sybase package. I guess generally more packages.
  • A comprehensive list of HOWTOs and FAQs online somewhere. (Yes, I know about the RDP... It's just not quite at the level of the Linux Documentation Project yet...)
    Along that vein, a ruby equivielent to perldoc would be nice.
    A new cgi library would also be quite nice.
  • 1) dynamically query for interface help.
    I would really like to have the ability to query any method
    for help on how to use its interface, e.g.:
    someModule.someMethod.help OR
    someModule.help(someMethod) OR
    help(someModule::someMethod)
    (I do not mean to exclude classes, from this)
    2) dynamically get the source for specific classes/methods etc.
    (This would help #1 and also towards a smalltalk-ish browser)
    3) important: better version control, better installation architecture
    design to allow multiple versions of ruby to be installed.
    (e.g. suppose you have 127 ruby scripts using v1.6.0,
    and you upgradeto v1.6.x? The new ruby will not necessarily
    work with those scripts. How do you ensure those scripts still
    have access to the old ruby without having to go and manually
    change lots of code?)
    4) a more robust Windows port
    5) an IDE with deployment tools
  • More documentation, esp. on creating GUIs. Also, an IDE would be nice.
  • more people using the language
  • Binary packaging for distribution
  • An official GUI toolkit
  • More docs, including more translations of the Japanese material, more on embedding ruby in other apps, more on how to package a ruby app. More ruby support in IDEs/editors.
  • Something akin to The Perl Cookbook - code snippets for common tasks; more modules.
  • More modules
  • Downloadable HTML tarball of help, tips, techniques.
  • ?
  • LOL
    I don't know what things already does it
    ^___^
  • I can't send a command to the shell with `` if it contains quotes. This will be a showstopper.
  • I need to play around more with the language before I can whether I think there are some constructs that are really missing. Apart from that:
    Support for 8-bit character encodings, at least ISO-8859-1.
    Support for multithreading with native threads.
    An implementation for a JVM, similar to JPython/Jython is for Python would be useful.
    For example, I use JPython for a lot of test code which interacts with various Java APIs.
    A major undertaking to do something like that, so I don't expect that to happen and definitely not anytime soon.
  • 1) APIs and standards similar to those developed for Java, such as rubyBeans, RMI, servlets
    2) Cookbook, Help, Reference, in a form accessible using F1 in common editors.
  • Bigger (CPAN-esque) library, particularly for web-related stuff. A more consistent way to install new classes - every module seems to have a slightly different installation routine (compared to Perl's totally standard make; make test; make install;) and I nearly lost my marbles trying to get MySQL drivers to find the relevant header file.
  • More libraries (maybe a more 'formalized' library system like Perl has). Of course, if/when I can, I'll contribute lirbary code.
  • More modules, better documentation.
  • more available modules, like CPAN for perl
  • * A simple IDE
    * A debugger
  • GUI interactions (wxWindows, TK inter, etc)
    These may exist, I haven't done exhaustive
    research on it yet.
  • a big-project in Ruby, to get more acceptance and publicy
  • easy integration with some GUI
  • I wish the libraries that provide XML support were more full-featured.
  • A great big giant do-anything *consistant*, *cross-platform* standard library like Perl, Python, and Java come with.
    And a better Emacs ruby-mode.
  • keyword arguments
    M17N (I'm currently working on it)
    performance tuning
    cleaner implementation ;-)
  • More books (looking forward to Matz's). Books on general
    topics (like OO) that use Ruby for their examples. On-line cookbook
    (which I'm involved with brainstorming on currently).
    In short: the next plateau of documentation and availability of robust,
    modular code of various kinds. I can't think of any major
    underlying omissions in the language, for my purposes.
  • Better documentation
  • Performance speed up.
  • A bigger selection of per made modules like CPAN for Perl. But if I want it I'm going to have to build it. Better GUI bindings would be nice.
  • I'll get back to you
  • A huge community as Perl with the friendly atmosphere the Ruby community has.
    Allowance to use Ruby at work all the time.
    Even more Win32 support.
    A couple of libraries
  • Greater acceptance in the western world and a much larger Ruby Application Archive.
  • Better documentation! ;-)
  • more documents and more users.
  • i haven't decided yet
  • f
  • Support for Mingw(or any other free compiler except cygwin) out of the box for extensions.
    or a simple tutorial on buildind those extension on Mingw on windows yeah HOW? a configure.rb that works!?!? ruby compiles just fine but the extensions that aren't part of the release?? they don't. Unfortunately this not so 'lil trouble has sent me to square one.
  • IDE
  • More bindings :-)
    Good GUI binding - I've been lurking on the GUIs for Rubys thread.
    I make use of the large body of python work. I realize that it takes time and energy to accumulate the libaries, etc. Ruby seems well on its way.
  • Capability to serialize Proc's and blocks (needs bytecode?)
  • Easy distribution would make it more easy to distribute ruby-apps to people who haven't got the time or competence to download the entire ruby-interpreter. Being able to make a binary to what ever platform would be very useful.
    There's also been talk about class browsers, IDE and so on, but portability seems a bigger issue to begin with - at least when comparing to other languages like Python or Perl.
    Knowing about the basic language of SmallTalk, it would also be very helpful to be able to see Ruby's built-in classes, modules and kernel-methods on a source-level, a kind of self-documenting Ruby. It's an ekstremely powerful feature of SmallTalk that be a awsome to have in Ruby as well.
  • More and better documentation, especially for Windows implementations.
  • More docs, including more translations of the Japanese material, more on embedding ruby in other apps, more on how to package a ruby app. More ruby support in IDEs/editors.
  • I wish Ruby had a CSP-like concurrency mechanism rather than monitor-like threads. It could have borrowed these good ideas from Erlang (http://www.erlang.org)
  • I don't know yet.
  • More uniform cross-platform support.
    Better documentation.
  • comprehensive documentation. http://www.rubycentral.com/ref/ is incomplete
  • Maybe an IDE? Emacs, vi and irb will do fine for the moment!
  • Documentation
    RAA to become like CPAN
    Better GUI bindings
    More users!
  • 1) native callout to perl to make the use of perl's huge CPAN almost trivial.
    2) auto-vivify like perl (possible?) Maybe you can guess that x[0]
  • - A perl-like debugger (command line oriented)
    - A tighter integration with emacs (list functions in ruby-mode)
  • Needs more libraries a la CPAN. I've started contributing with Log4r and providing feedback, support on existing libraries.
  • What would make Ruby more useful for me are features that would allow me to use it in production (I'm a web developer). I'd love to switch to Ruby full-time, but I can't realistically make the case for it without a number of features already available to me elsewhere. Most of the following would be necessary for me to be able to make the switch.
    Extension modules: 1) consistent, uniform installation procedures, 2) organized library of them, 3) more of them (this will come with time, I'm sure) . . . that is, I want a CPAN for Ruby.
    Better database support. Ruby needs something like Perl's DBI module. Someone's started one, but it doesn't really work yet, and others writing database extensions don't seem interested in it. This is so important for real work that it ought to get the attention of the leaders of the Ruby community. I can't justify allocating resources to producing my own Ruby DBI when Perl already serves one up. The Ruby database-specific extensions aren't very attractive when I can't know for sure what platform my code will have to run on and what database backend I'll need to use.
    Something like PerlIS.dll for IIS. I'm stuck on a Windows platform in my current position so I can't use mod_ruby, and I can't really justify arguing for a change to Ruby in our production code without something like this.
    A few Perl syntax features I feel the lack of. In particular, I really miss being able to take random slices of arrays and hashes with the bracket syntax and being able to use slices as lvalues. I'd really like to be able to write myHash['one','two','three']
  • Non crashing windows version.
    IDE
    Longer tutorial
  • I don't know yet.
  • Absolutely nothing.. oh yes! An operating system totally written with Ruby ;-)
  • Having Microsoft or Sun declare it their official language (or at least the company where I work). Actually, perhaps the fact that I have no suggestions also answers question #6.
  • In the long run, a package repository and associated utility for Win32 programmers, similar to ActiveState's PPM. Documentation, documentation, documentation. This is one of Perl's great strengths.
  • Better english documentation for additional packages. CPAN like archive would be good thing.
  • Optional typechecking at least on method interfaces.
  • An IDE for linux like the Windows version
  • Better syntax errors (too often I get "Syntax error at line [file length + 1], which is really cryptic). Javadoc-style ruby documentation (is that already there and I'm being stupid?). A shortcut for initialize a, b; @a, @b
  • More Windows libraries; unified GUI solution
  • At first, I thought the language was a little cryptic. I have learned to really enjoy it's simplicity and power.
  • Potentially a compiled version or an iterpreter built for speed
  • More books :-)
  • more mature libraries
  • I need more, simple examples
  • An Apache module for web programming.
  • I long for the day when I can do GUI programming and not have to have TCL/TK installed on each machine, or GTK or whatever. SWING is the only thing that comes close to this. It'd be nice if there was bytecode compilation, or at least a nice method of packaging everything up. There's nothing worse than creating an app that says something like:
    Before installing this app, you need to have TCL/TK installed (> 8), you must have Image Magick installed, you must have....
    8 hours later the poor chap actually gets to install your code...
  • easy to learn. EX. If you want to divide a line, just line.split(Regexp). On perl, how do I do?
  • Speed improvements.
  • i hate all the "end" things.
    i largely prefer python, because you are forced to give your source code a clean look.
  • More documentation in English/French.
  • I will be developing various Internet related modules for Ruby useful for developing spiders (which I do for a living) and web agents.
  • Gtk bindings, a clone of Perl's DBI
  • Matz' advertence
  • a byte compiler
    doccumentation
    scientific libraries (narray,netcdf)
    application server framework (j2ee style)
  • file utility tools
  • GUI toolkit available on Mac as well as others
  • A possibility to use Java 2 (especially for using Swing GUIs).
    The Java ruby interface is not up to date and does not work.
  • A Ruby platform (!) analogous to the Java platform. So you can easily fetch code written on linux, dump int on the win platform and run it!
    You should be able to write the ruby-scripts indepent of OS.
  • A GUI
  • - Design by Contract: pre-, postconditions and class invariants build into the language.
    - Pre-emptive threadscheduling. (in general: better threadscheduler).
  • A CPANish archive
  • better docs, especially on web and database stuff.
  • extended time to tinker ;-)
  • A nice object browser that was fully integrated
    with GNU/emacs.
    A nice, high-level 3D package (ala Java3D).
  • Better facilities for packaging things. I find it much easier to develop large apps in Java.
    Also better documentation facilities; JavaDoc is less work than the inline docs in Ruby.
  • none
  • A set of standard modules for services like sockets
  • A compiler that would link my Ruby application code (program, libraries, modules, etc.) into a single Windows .exe--so I can distribute programs to others at my college to use without needing to install the Ruby interpreter on every machine.
  • * Ease of learning - Ruby is so far the most welcoming language I have encountered.
    * Power - little code goes a long way.
  • more (english) documentation
    numerical limits (e.g., like c's limits.h)
    redhat rpm's
    ability to compile for performance bits
  • Means of compiling Ruby code or at least getting a stand-alone executable.
    Other ways of migrating application prorotype to fast and stand-alone application. Optimizations.
    Lots of extensions so that I don't have to go to other solutions.
  • native threads, speed improvements, more
    stuff in the RAA (I'll do my part :->)
  • Better database support!
  • Everthing special to Japanese Information processing.
  • If the expression evalulator would work on OSX, that would be very nice.
    It would also be very nice if it could serve as an Open Scripting service on the Mac.
  • documentation
  • access to machine or compiler-specific limits, such as smallest float, machine epsilon, number of significant digits for floating-point numbers
    more comprehensive profiler
  • Better libraries/bigger community.
    Some equivalent of Perl's strict. I like the
    option of catching some types of common errors
    immediately. (I call strict the Perl
    spellchecker. It isn't very good but it is a
    world better than nothing.)
  • More documentation. More "dummies" and "teach yourself in 24hours" books. More online tutorials and examples for newbies like myself.
  • More *detailed* English books on the subject.
  • It seems to me that providing more documentation e.g. about the use of Ruby in upcoming technologies like Webservices would be great.
  • An official bytecode or (preferably) native compiler. This is more so that applications can be distributed as a unit without source in the manner of Java .jars or executables rather than to boost performance (although better performance is of course always welcome).
  • Speed. I sometimes feel Ruby execution speed is a bit low.
  • i like eruby, but i'd really like to see a more complete framework with session management, as in JSP/Servlets.
  • faster, saving bytecode files (like Python .pyc), FOX GUI bindings, Fltk bindings, more libraries
  • Larger library (eg., comparable to CPAN), especially a cleaner more established database interface (ie., an ODBC interface). A more widely-used, thoroughly-tested, and confidence-inspiring Ruby2C compiler so we can write our code in Ruby and ship binaries. BTW, you really should rewrite your K&R C into ANSI C!
  • equivalents to perldoc and CPAN 8-)
  • * bytecode + jit executer.
    * in-depth articles.
  • In order of need:
    1) A compiler for Ruby. I'm sometimes tasked with converting some hideous shell script(s) to something else because the shell script is too slow. The speed increase of Ruby isn't as dramatic as a compiled program. Ruby -> Bytecode, or Ruby -> C would be really, really useful. The latest rb2c is for Ruby 1.4, and segfaults under Ruby 1.6 (compiling rb2c was problematic)
    2) Binary distributions. I'm a contractor, and often work on systems which I don't have enough control over to install a compiler to build Ruby.
    3) Along the same lines as (1), it would be useful to have a single binary of Ruby that *is* a Ruby installation, so that Ruby doesn't even need to be installed.
  • More documentation and books
  • An integrated visual environment like Squeak. I know, I know there is GemFinder, but I haven't been able to load the damn thing yet.
  • Accordance with the ANSI C standard.
  • I haven't used it enough to really know
  • Script repository like perl (www.cpan.org)
  • more documentation. standardized gui library.
  • More libraries and books to read on it.
  • more portable (the win32 port is not all there)
    a link to java to use java classes in/from ruby
    more complete networking (I'm a newbie, so maybe I missed something, but ...)
    a version for my Palm
  • when it becomes more popular
  • a chance to touch the almighty matz, maybe rub off some of his cool-juice. the RAA also needs to be developed more (and i'm working on that myself).
  • 1, Textmode user interface -> I'm writting it now. 2, Speed improvements.
  • a ruby cookbook
  • - Get as mature and popular as perl, so that I could also use it in production. Now I would not try to propose ruby as an alternative to perl to my managers.
    - Some features form Lisp (esp. EuLisp):
    -- defmacro
    -- MOP (Meta object protocol)
    - IDE
    - generic functions (multi methods)
  • Directed brain implants.
  • Native threads.
  • simpler access to GUI
  • a load() which would run in the current class instance, and a DBI/JDBC type interface for databases.
  • More documentation
    MySQL and/or Oracle packages
  • Better documentation. Package management tools.
  • I am attempting to use the Ruby -> Tk interface and a manual of the parameters in English would be helpful. I have now found the excellent examples in rtkdemos-en
    I have recently had an installation problem on Linux which turned out to be because I did not have the X11 development headers installed. It would be good if this was reported on 'make' rather than silently passed over.
  • Better web tools.
    Simpler extensions installation.
    More recent version installed here ;-)
  • More syntactic control for creating task-specfic sublanguages (hygienic macros?).
    Common back-end with other languages (parrot).
    Multiple dispatch.
  • What I need the most right now is time to study Ruby in earnest.
  • dynamic compilation
  • more extensions
  • More libraries & NATIVE THREADING.
  • Larger standard library. Inteface to Java like JPython provides.
  • The syntax just seems a bit iffy. Relying on whitespace, especially non-
    whitespace, in parsing is really evil. One thing I liked about C: it's syntax was completely understandable.
  • Java integration
  • Better cross-platform support in the standard libraries, such as sockets. More standard libraries for XML and Internet development. Less posix-ness in the builtin classes.
  • Getting library coverage similar to Perl or Python.
  • 1. Some way to extend the syntax without having to use C. I'd like to be able to do things like add a notation for type checking.
    2. A way to actually get at the call stack itself and the current values of the bindings, rather than just the names of the frames, would be handy. Maybe I just haven't found that part yet.
    3. An easy way to deploy Ruby applications.
    4. Along the lines of 1, an interface to the parser to allow modifying of code in an object-oriented way. Maybe I havent' found this yet, either.
    5. Need a package system to organize modules in a hierarchy of namespaces like Python?
  • don't know enough to answer that one yet :)
  • 1. Library for accessing the Windows registry. 2. Ruby cookbook would be great. 3. Better backtick support on Win32. Have to use `cmd /c dir *.*` instead of `dir *.*` 4. E-mail support could be better. 5. Java integration
  • method overloading, examples of enterprise apps developed with it
  • I'd like to see a large and well maintained collection of
    support code (Much like CPAN) available and indexed.
  • Web App framework, like iOWA or the others that seem to be popping up.
  • A free banana
  • To have a convenient installer for 'every' platform
  • More mature GTK/Gnome-bindings,
    A better OS-independent GUI than tk. Tk sucks bigtime. wxruby would rule
  • More source code examples would be nice but I think in time it will cease to be an issue.
  • I don't really know yet, but a IDE would be faily high on the list.
  • Something like CPAN and the cpan-program.
    More hours in the day ;-)
  • Better documentation, especially for GUI frameworks (TK, GTK+)
    An equivalent of JavaDoc HTML docs shipped with Ruby release
  • too early to tell
  • More documentation with examples. The pick-axe book is great - I probably need to read it and digest it more. But, for example, trying to use the Win32 OLE classes to get named constants took a little bit of effort - I realize that some of this is because many of the contributors are Japanese and so there is more Japanese documentation than English. That's a shame - but hardly unreasonable!
  • More consistant ways to extend the language
    itself (hooks like method_added, what
    delegator does, etc.)
    Byte code or other concise form that is distributatble without source
    Some way to use compiled code within iterator
    body without resorting to an external C module.
  • * Enhancement/standardization/documentation of the libraries
    * Installation in more ISPs
    * More DBMS/XML support
    * Web application server/framework such like Zope or WebObjects
  • byte coding, ruby virtual machine, os level threading
  • GUI interface, compiler (not necessarily to a native format)
  • A tutorial on using SWIG to wrap libraries for Ruby.
  • Application prototyping
  • more lib modules
  • More english documentation, although Ruby in a nutshell is an excellent reference, I feel that resources available to beginners are lacking. Having previous programming expierince I was able to piece it together, but for someone new to programming in general I feel it would be quite a feat to take on Ruby as a first language, not because of the language itself, but the lack of resources geared toward begining programmers.
  • Better integrated XML support
  • bytecode compilation
  • no comments, still learning!
  • 1.) Broader User community.
    2.) We need a ruby application server.
  • CRAN (Comprehensive RUBY archive network) ;-)
  • A ruby -> C compiler.
  • Good graphics toolkit. I found the Tk one is not well documented and was therefore very
    hard to use (it might be even with good docs, I used it some with Perl and it's okay, but
    not great IMHO).
    A graphics toolkit that was more Rubyesque would be an improvement, ie make the graphics
    class-based (OO) and easily extensible (somewhat like Java but keep Ruby's simplicity of
    expression), and it would be a whole lot easier to use (although this may be an awful lot of
    work to develop, I don't know).
  • More external libraries for database access, JMS etc
  • More time to learn the language!
  • Even faster?
  • A better Windows IDE than RubyWin
    Ruby script to executable ability
  • General improvements to Ruby/Tk-- maybe standalone implementation (tcl/tk shared libraries not needed), more English docs.
  • good Java integration
    strong support for Web Services
  • An IDE with Object browser
    Tighter integration with Glade or Qt Designer
    Better web application development tools like PHP or Zope. If we could have a Zope like environment built with ruby and extendable with Ruby. It would be great.
  • Some of the modules that ship with ruby are a little rough around the edges (bugs), however for the most part they're good.
    Also, the best thing that would also help make ruby better is simply more supporting modules, similar to perl's massive CPAN.
  • english documentation
  • A syntax highlighting for <put any editor here> that works really good.
    Perhaps an IDE in the spirit of Ruby itself.
  • If it had a library for everything I need ;)
  • ruby to c compiler
  • - bytecode generator
    - comfort level to use it with high volume commercial web applications and database se (don't know how to gain that comfort level other than to use it, or wait until others use it; one problem of using it is to have an exit strategy to recover if problems start arising)
  • I (unfortunately) have to do most of my programming in Windows. I don't like to use cygwin, so it would be useful for Ruby to have more modules that are ready "out of the box" for Windows. It would be great if the native Windows support became good enough that the cygwin port was no longer needed.
  • more examples.
    more robust web modules
    tighter integration with apache
  • Money. Documentation on newer versions than the pickaxe book covers. Macros, maybe. Lexical metaclass inheritance, perhaps. A faster profiler. A faster runtime. Money. Some (optional) way to specify type coercion on method arguments. Assertions. More aggressive garbage collection. More English. A good, free IDE that really understands ruby. Independent sub-interpretters, with their own execution environment, as first-class objects, a'la tcl.
  • A text user interface (not dialog).
  • Improvements on RAA (like CPAN).
  • Standardized libraries, better support for XML/XSLT and databases, standard GUI library, web application server in pure Ruby
  • reentrance/multithreading
  • More comprehensive CGI and DB support. On the DB side, an easier-to-obtain and install, and more object-oriented set of interfaces (meaning less Perl-like) would be great.
  • A consistent, cross platform IDE.
  • Rite. RAA.succ, FreeRIDE, RubyGems
    and sort of analogous Ruby Beans (as a parallel to Java Beans)
  • Java integration
    standard db library, sybase, oracle, postgresql
    don't have to scrounge for gtk, qt integration
    libs
    more users using it
    more awareness
  • an interactive IDE like the one you get used to if you do Smalltalk programming. Make Ruby run on the JVM and to access Java objects (Swing for example)
  • Basically, more CPAN-type stuff. A DBI (which I know is being worked on), and a clean module-install procedure that everyone agrees on.
  • - a more c++ style streams/iterators/container lib
    - c++ extension interface
    - compiler
  • A built-in document format simliar to perl's POD.
  • The ability to copy my programs to other (non-rubyist) people VERY easily, which in practise means making an exe. Even if it's just the sources, required libraries and interpreter bundled into a self-standing program file.
  • .net, COM, Win32, *and* a good Linux GUI API.
  • A generic database interface. A Smalltalk-like environment. A graphical debugger.
  • A CPAN-like database (documentation and all), faster on Win32 platform
  • I haven't found any major drawbacks yet.
  • If it was easier to develop graphical applications. I'm thinking about API, tutorials and better support for GTK, Gnome etc.
    Better graphical support for Windows would be great.
  • Better Windows support, with 1 distribution and a comprehensive documentation system.
  • Refactoring browser
    More documentation (books, articles etc)
  • improvement of my own knowledge and skills and more practice
  • Better standardization (we don't need puts, print, printf and so on. one big, good one would do) and a larger userbase (so the ruby-information on the web grew).
  • wxRuby
    (wrapper classes for wxwindows would catapult ruby into another dimension)
  • I often have surprises around using the chomp command on the Cygwin based version to remove the EOL. To be safe, I usually resort to use something like the following.
    def Helpers.removeEOL(line)
    line.
    chomp("\r
    ").
    chomp
    end
    It would probably better to add that function to the String class though.
  • You guys seem to be covering these already:
    -speed
    -namespaces or some means of handling large projects
    -.Net integration
    -simpler GUI programming (I'm working on this one)
  • If we have an extension for allegro game programming library, we can write games easily and like to learn Ruby.
    Gamers will like to learn Ruby.
  • Maybe a class/method browser, or IDE like Squeak.
  • The only thing that stops me right now from dropping perl altogether and doing everything in ruby is the lack of an interface to Informix. I know there is a ruby-informix package, but the only web pages that refer to it are in Japanese and I cannot seem to find a place to download it even to get started.
  • 1) Byte-code 'pre-compile'
    2) Able to create 'stand-alone' app.
  • Something like an enum would be handy for a lot of things...
    I realize it's a pipe-dream, but a toolkit-agnostic GUI (and TUI! :) API would be *very* cool... esp if it could use existing toolkits as backends (I have heard of wxwindows, seems a bit heavy)
    Standard install system would be nice.
    Sometimes the documentation can be a pain (English :/). "programming ruby" is good, but I don't think the layout is well suited to online form (I'm too cheap to buy it, sorry :). The problem is mainly with RAA libraries, or builtin classes that aren't in the book.
    Some more builtin datatypes would be nice sometimes, but some notes in the docs about performance characteristics of functions would be an ok alternative.
    A nice (fast) geometry library in raa would be cool. Basic support for Points, Vectors, (Poly?)Lines, Rectangles, and AffineTransformations would be an excellent start - these are all things that anything even slightly graphical tends to use a lot. !
  • If I could get outbound TCP connections to work on Win2K.
  • More consistent method naming... easier to remember
    Mutex#try_lock
    ParseDate.parsedate
    MyClass#methodName (recommended in Programming Ruby)
    Names should also follow "least surprise" philosophy.
    No "synonyms".. to read other's code I have to remember all synonyms.
  • More modules to support more things like WDDX. An easier way to find modules I want like how CPAN works.
  • More portable to places like palmOS, pocketPC, and TI calculators, as well as embedded devices.
  • Better documentation and reference, fatter RAA, better RAA, automated installation, development tools (like SWIG), great GUIs, and interfaces to other systems and languages. New interpreter.
  • a better developed integration into apache, further development of networking libraries (mx-record check i.e.), more documentation of course, better database connectivity
  • I have dabbled with Python, and their tutor-list seems to
    work better than ruby-lang.
    Posts are assembled and mailed out a couple times a day wiitha general Tutor@ header, instead of individual email addresses.
  • An error/warning free compile/make cycle using the standard OSF1 V4.0 1229 alpha compiler and make tools.
    A Ruby Virtual Machine and a bytecode compile similar to what is available with Java.
  • A working ORB, more gnome-bindings.
  • zope for ruby?
  • A byte-compiler and more modules
  • 1. Ruby Macros
    2. Full lexical scoping
  • An english speaking dev- mailing list
  • Better documentation and reference, fatter RAA, better RAA, automated installation, development tools (like SWIG), great GUIs, and interfaces to other systems and languages. New interpreter.
  • a better developed integration into apache, further development of networking libraries (mx-record check i.e.), more documentation of course, better database connectivity
  • more modules for database manipulation
  • CPAN-like storage of all modules, and the speed of Perl
  • more packages (like perl's CPAN)
    more info on how to install packages (like perl's PPM- is there a Ruby analog? i couldn't find it.)
    more programming examples online- eg. here's the Ruby way to read from a file, here's the Ruby way to manage cookies when getting web pages, etc.
  • more docs, more libs like perl. The AW book is good, but I could use more info about how to do things the ruby+oo way, as opposed to the perl way.
  • A larger standard library. A standard GUI toolkit (not tcl/tk)
  • Mostly just more class libraries. It would be nice if ultimately we
    had something as nice as the perl cpan stuff.
  • Ha! Ask me again when I've learned more about it!
  • IDE
    compiler
  • multiple inherintance, or � la Java interfaces
  • More documentation, tutorials and examples (and not for de 'hello world'-suite but for quite complex projects).
  • execution efficiency (RubyVM, JIT)
  • More documentation, greater availability of useful modules.
  • native GUI, native OODBMS, more app frameworks (yeah, I know, just get off my butt and write them!)
  • A lot of libraries. It is not *too* funny to have to write stuff like math extensions and things like that.
  • Tighter Windows integration especialy as a COM Server
  • would be useful to be able to distribute a window .exe
    A VB style visual IDE would be useful (then I wouldn't have to do VB)
  • A real oop step to windowing toolkits like
    FXRuby, Ruby/[Perl-Yuck!]TK, Ruby/GTK with
    a uniform api towards the ruby developer,
    where you just select which library you want to
    use in the end and don't change any other line
    of code [need not use all of those toolkit's
    strengths of course] - But well, that's a real
    dream anyways
  • If it were a bit faster in general, it would be nicer for large amounts of text processing.
  • More documentation and real-world examples. No complaints though, what is available is enough. More is just better. ;-)
  • * an uniform interface for the documentation shipped with ruby itself
    * a better way to convert data from one type to another (.to_s, to_i etc. all suck - we should maybe have something like Class.new_from() which the ruby interpreter automatically uses)
    * a better RAA (put stuff onsite, common format for documentation, tool to automatically install new modules)
    * more community! (e. g. feature articles on ruby-lang.org)
  • -integration of drb in ruby package
  • More modules!
  • 1. more libs.
    2. posted RCRs on details
  • Speed improvements
  • - better documentation
    - sources (even pseudo-sources) for *all* classes, so you can read the "source" if the documentation is not sufficient
    - declaration (without typing) of variable names like in Smalltalk, to prevent typos
    - possibility to put the do or then on the next line, if find:
    if foo?
    then x
    else y
    end
    much more readable than:
    if foo? then
    x
    else
    y
    end
    but that's just IMHO
    - support for compiling ruby code to bytecode (like .elc files in emacs)
  • Database
  • Enough industry acceptance to be able to develop Web applications in Ruby...
  • a ruby compiler which produces binary files
  • As a ruby newbie, my scripts often contain stupid errors. (Such as doing "if fi" instead of "if end"). When this happens, ruby reports a "parse error" on a line far from the error. It would be nice if this error reporting was more specific.
  • A way of creating stand-alone Win32/Mac apps that has a stripped down ruby binary. I have used Robert Feldt's rbwrap which works fine but it produces apps that are at least 1.7 MBs and 5.7MB if it includes the FXRuby library (fox.so)...
  • RAA.succ
    standards compliant XML parser
  • A better IDE.
  • Consistent "!" usage for all mutating methods (like scheme). You shouldn't have to look this up or have to memorize such things.
    A completed GTK+ port, with English docs, with an InstallShield distribution that uses Win32 Gimp DLLs.
    *Both* a bytecode compiler (for proprietary source code, and for *fast* startup of big applications) and a single file, completely self-contained Ruby, library, and application distribution system.
    A better performing (non-Tcl) Tk port with full English documentation would have been nice.
    Both a printed and an on-line searchable Ruby Cookbook would be very helpful.
  • The Ruby Application Archive is ok, but if you compare it to Perl's CPAN ...
    A lot of libraries are still missing (I will do my best to provide some of them ;-)) and server-side Ruby is a very young subject, I think.
  • An obvious, easy way to install and make use of (C) extension libraries (not just Ruby modules).
    I haven't tried in a while, but it was a little painful before, with each extension having its own way of being managed and installed.
    A truly OO database interface, rather than a Perl-derived one.
  • What you think is what you write.
  • Time to tinker with it more ;-)
    I would like to see more pure OO examples
    as I am new OO coding techniques.
  • Examples
  • English documentation
    Faster dev cycle
  • Integration with Java.
  • more books
  • A simple smalltalk-like ide.
    Certainly the ability to be able to execute sections of code would be _wonderful_
    If we could put "stop" statements - a la BASIC - in the source code while it's being written/tested; that would be similarly wonderful.
  • Make it more popular so you don't have to distribute the interpreter and runtime-system.
    Extend the standard library
  • A set of GUI widgets that are cross-platform (not TK).
  • Knowing it better is suppose. :)
  • more Internet Service Providers offering Ruby, mod-ruby, erb.
  • can program with objects is the biggest benefit
  • a nice IDE (something like IDEA by IntelliJ) and a *easy* to use GUI framework.. i know there are ones out there but the learning curve for Swing seemed tiny in comparision to Fox/Tk/etc
  • a integrated development enviroment with source code debugging.
  • I need something like Perl's DBI module. Maybe it is already there. I am brand new.
  • Clarify the licensing. None of this "other people may have various coprights to various parts". If so, rewrite those parts. Then release as either BSD or GPL licensing. "Submarine rights" are just too great a risk for serious useage. Until then, it's just a toy "learn how to program in 24 hours" type of language. Also, a real COMPILER, please!!!
  • whishless happy at the moment
  • Native threads would be great, but that's just sugar on the top of the cake. The biggie would have to be some kind of compiler so that I can have commercial Apps based on Ruby. C extensions work, but having logic in a binary form would be invaluable!
  • A CPAN-like ability to download and install/update new modules based only on knowning the name of the package. A code-generating UML tools would also be very, very useful -- perhaps someone could adapt ArgoUML to emit Ruby classes.
  • All Japanese documentation etc translated into English.
  • Lots more documentation, and if IRB didn't freeze up in RubyWin
  • CPAN !!!
    Much more module and library (like perl).
    Possibility to convert Ruby into bytecode or compiling it (like ocaml does).
    A newsgroup in French.
  • better integration with vim
Other comments:
  • I believe ruby is headed for a bright future.
  • Ruby rocks!
  • Matz obviously did something right. He wrote a language you can pick up and feel proficient in after about an hour of use, yet it's still a powerful language that is a lot of fun to use.
  • Good job!
  • Keeo up the good work!
  • I've been looking to help. One problem I found is that examples seem to not be that complex (perhaps that is good) or rather, trivial. It took me a bit to figure out how to write a non-trivial program. Ruby does this nicely, just not many examples of it.
    Perhaps I can make it available?
    sahuagin@mediaone.net
  • Ruby is great!
    I think more newbie-related stuff like you can find on http://www.python.org/doc/Newbies.html would make it easier for beginners to get started and engaged in the language. Maybe also a mailing-list for beginners like:
    tutor@python.org
    http://groups.yahoo.com/group/perl-beginner/
    could be a help for many that think ruby-talk is too technical and advanced for them when they have just get started.
  • I was reading The Pragmatic Programmer's Guide which I downloaded together with the program itself. After reading for a few hours I still don't know how to compile/distribute a program. Maybe this topic could be handled in more detail or more obvious.
  • At last language that makes sense to a old amateur!
  • Seriously, I am not a programmer, and yet I am able to accomplish simple things in Ruby. I love it.
  • the ruby ml is a valuable source of information
  • Thanks matz! And thanks Andrew and David!
  • Ruby regular expressions seem idiosyncratic to anyone used to Perl. I would REALLY like to see simple forms like s/this/that/ (re)introduced into Ruby, particularly when it comes time to do something more complex:
    x.sub!( /(_+\010+)([a-zA-Z]+\b)/, "<i>" + '\2' + "</i>" )
    took me several baffling hours to discover. (This helps to convert manpages to html, so elegance is not really a criterion ;-)
  • I really like this language although I've never had real OO-programming experience. It's clear and very elegant.
  • this is just very good general-purpose language.
  • Well done, Matz!
  • keep up good works
  • I'm currently torn between Ruby and Python; both some to have some key features that the other lacks.
  • Just a big thank you to all the people who make Ruby happen.
  • I've been loving Ruby since I saw it: that's really funny programming!!
  • ruby is great and my favorite hobby now! i wish there were more ruby user groups (like the perlmongers). keep up the good work!
  • Nah.
  • with two developer communities not entirely handy in each other's language, even babel fish overview of what is going on on the other side would be useful. I get the impression that there is a loss of developemtn speed and overlap of effort at times, especially as the number of english speakers handy in technical hapanese and also good programmers is limited.
  • We need some thing like CPAN and More Libs
  • Very impressed with Ruby and its community
  • 1. Major effort should be put to finalize language definition. So scripts will no need updates between versions.
    2. thread should be able to switch slice in IO operations, so it will be really speed-booster.
  • I saw the recent thread on Array/set subtraction,
    and I have to say I was *very* afraid that people
    were so willing to mix set and array semantics
    too freely. That kind of thing leads to madness, and the madness comes much sooner than you'd think. Already, Ruby has made the classic error
    of overloading "+" to mean "concatenate"; the
    functional language people are a bit academic at
    times, but *they* know that + and - are inverses,
    so invented "++" to be concatenate. I could go on...
  • Japanese people always make cool stuff.
  • There is way to few docs out there and 70% of it seems to be in jap. Immagine where Python would be today if it had all the docs written in dutch!
  • Thanks, congrats, and keep up the good work !
  • Coming from the Objective C world, I'd love to see arguments mixed in with method names - it's much harder to forget an argument, or get things out of order when the method is "foo.setX: xValue andY: yValue". Objective C has shown that the surrounding brackets notation does not collide with array index notation, so to make the above unambiguous in more complex expressions: "[foo setX: xValue andY: yValue]"
    Not that it's likely to happen, but hey! you asked...
    Anyway, I'm having fun. Ruby is language #13 for me.
  • Great language. I made the choice to learn Ruby, rather than to keep learning more perl. Perl has been helpful in getting things done, but it is not as clean as Ruby, it lacks good OO support, and is just generally not as nice a fit with my personality as is Ruby.
  • nice language, cool syntax, just like it.
  • I haven't been as excited about a programming language since I first started using Perl years ago.
  • I'm not sure if I like or dislike this, so I'll put it here:
    flexible syntax.
    Sure comes in handy sometimes, and is nice when teaching people how to program, but it's often quite counterintuitive how the code chooses its precedence. I see no solution other than having a more strict syntax... but I like flexible syntax... it's just that I have many more syntax errors than I ever had before, and that's the one thing a compiler is good for!
  • Currently I am just experimenting but I would like to be able to use ruby at work and not only at my home playground.
  • I'm an old C/perl4 procedural hack. When I started with C++ I worked very hard to learn OO. The more I learned OO the more I realized that C++ was getting in my way more than helping me. I found perl5 to be just as conducive to procedural code as C++. I had heard of Ruby when I was trolling for the next thing, but it hadn't really caught my attention. It wasn't until I ran across Squeak smalltalk that I realized that there were languages out there that actually promoted OO coding. Suddenly Ruby shone like a lighthouse through the storm. I am currently investigating the possibilities for using Ruby in our development environment and products.
  • Ruby-nuby-duby-duuuuuh!
  • Nope, keep up the good work!
  • Ruby, matz and Dave and Andy rock!! Keep up the good work!
  • Great language.
  • Without declarations or "Option Explicit" how do you make sure you haven't mis-typed a variable name?
  • Had a glance at Perl because I felt I needed to extend my knowledge portfolio to include a script language to have a language to do meta-programming and automations in. But it did not appeal to me. When a colleague made a kind of a public question (at the coffee table) to me about what I had been doing on my last weekend and asked if I'd learned Perl yet. That weekend I just read a a note about Ruby and replied: "No, i've been looking at Ruby." No response, it was obvious that this was something new to him. That day he downloaded User's Guides and stuff and talked about it like I knew anything about it. Then I had to learn it. I don't regret it. :-)
    Ruby needs to have everyone in its forums to push for it. Writing articles, telling all friends about it.
  • Really good work until now.
    I hope the current language elements are not modified too much, this would break existing code.
  • I'm ready to learn a new language. I've been heavily into Java. I think Ruby might be a nice complement to Java.
  • It is hard to learn because there are so many possibilities for anything.
    Document the most elegant approaches, and downplay the backward compatibility
    with every language imaginable. Iterators favored over explicit loops, for example.
  • When working on stuff that others will have to maintain, or others will take over, I am forced to use more mainstream langs such as Perl, ksh, and Java. As a manager, I don't get to code in C much anymore. When working on my own stuff, I try to use Ruby when possible!
  • I can run it under System 7?!? JOY!
    /me starts searching ruby-talk archives...
  • Ruby's presence on IRCnet could be moved - that service is
    too hard to connect to, is slow, and has constant splits.
    (Or maybe this is on purpose to discourage using it?)
    Every time I run ruby scripts it tries to gobble up the whole CPU.
    I can do this on my own system, but I think it may hinder
    its widespread use...
    I look forward to the overhaul of RAA. Too many things are neglected.
    I like the numbering on the mailing list, but not in front.
    How about:
    [ruby-talk] blah blah blah [ruby-talk:xxxx]
    (I think the non-threading capability is why http://marc.theaimsgroup.com
    discontinued archiving ruby-talk.)
    Finally, I think Ruby is going to take over ;-)
  • the mailing list is incredibly helpful
  • I thought Perl was the computer language I would have written if I could, but now I believe this to be Ruby.
  • Tried Ruby over a year ago, but went back to Perl. Now doing more in Ruby and less in Perl.
  • Looking forward to downloading latest stable build and get busy!
  • Keep up the good work.
  • Documentation in english, needed :-/
    something like PLEAC-Ruby, but more examples.
    *not more sites* ;-)
    ** more docs :-) **
  • I heard about Ruby first maybe 2-2 1/2 years ago when I read some article by Matz in comp.lang.python. I dismissed it then because it did not seem to provide much benefit vs Python at first sight, and it seemed to be too much Perl influence (the bad part with the cryptic variable names) to my liking.
    I should have looked more closely at it then it seems. I'm glad I did that this time. I stumbled on the "Programming Ruby" book at Amazon when I was looking at some XP litterature and that got me reading.
    I bought the book and have read a fair amount of it now.
  • Keep up the good work!
  • Keep up the good work!!!
    :)
  • I dislike the large number of "synonyms". I don't want to have to remember things like the fact that "next" and "succ" both increment by one.
  • Ruby may just be the coolest language I've yet come across. I'm looking forward to watching it take over the world...
  • thank you.
  • Hard to believe it's been only two months since
    I first picked up a certain pickaxe-adorned tome....
    Looking forward to the Ruby Century.
    -- David Black
  • I found the on-line documentation confusing. It actually hides a lot of information from the reader.
  • Is there really a Mac System 7 version? Would be great if there were.
  • Thanks for producing such a great book on the language.
  • f
  • Ruby looks powerfull specially with those extensions except that if in windows and no MSVS you usually can't use those, how can you compile'em?, give me/us only and only a little tutorial/howto on compiling an extension on windows with mingw any extension just any!(I've searched High and low and come out with nothing nich nada ). Ruby has become a lil' toy because without some of those extensions how much can you really do! dbi? sql? eruby mod_ruby I'm just frustrated!! guess I'll use php for some more time(unfortunately for me)
  • Thanks for a great language, and an open approach to making it better.
  • Even though I don't use C++ or SmallTalk very frequently any more, I've been using at least C++ at an advanced level (templates, Scott Meyers' Items and the basics of STL).
    I am also able to read SmallTalk-code very easily (SmallTalk Best Practice Patterns by Kent Beck is a walk in the park), but I haven't had the chance to use it very much because of the very steep curve in learning the class library and because of the differences in the IDEs and dialects.
  • Thanks to Matz and everyone else who is working to support this great language.
  • This Ruby isn't anything to do with http://www.it.dtu.dk/~ruby/ (I was looking for references to ruby and lambda calculus out of interest)
  • Matz is my new hero.
  • I wish I had met Ruby sooner, I could have saved myself a long and fairly unproductive detour through Java language & libraries!
  • Excellent books (pickaxe & the Pragmatic Programmer)
  • Thanks for ruby! The biggest stumbling block to acceptance is the lack of prewritten modules/packages, a la CPAN.
  • - Keep going !
  • The Ruby community introduced me to various modern concepts in programming such as Unit Testing, etc. Ruby is a great way for someone without a Computer Science background to pick up the essentials quickly.
  • Consider .NET. I don't know whether .NET will ever amount to anything, but this is an area where Ruby could quickly achieve parity with Perl and Python. If .NET does turn into an attraction, that will be an opportunity/occasion for many developers to consider switching languages, too. Ruby could pick up a lot of users in such a situation.
  • Please keep the good work. Ruby is by far the better programming language I ever used.
  • The only complaint that I have about Ruby is that it makes programming in other languages much less enjoyable. I often find myself thinking, "If this were Ruby, I'd be done already."
  • It's very exciting to see a language in its early stages, with many knowledgable people contributing ideas (many of which are over this informally-trained programmer's head!) in an atmosphere of enthused respect.
    Jonathan Feinberg
    jdf@pobox.com
  • Keep up the nice work!
  • I tried python and just couldn't get over every other word being "self"! I'm a long-time java and C++ programmer and the loose typing and fully OO nature of ruby is just lovely.
    Thank you Matz and the Ruby developer community.
  • A great language!
  • The more I use it the more I like it!
  • Nothing but a pleasure learning and using the language
  • This looks like a useful language for testing. Im glad I found it
  • no
  • If only all the applications that I use had been SWIG'd and embed a Ruby interpreter!
  • i just don't see what makes ruby different from "just another python dialect"
  • Keep the good work!
  • Love Ruby. I'd love to use it more. Key areas missing are:
    1) Database access (DBI clone needed)
    2) Graphical bindings (Gtk, Win32, etc)
  • I'm not nuby to this list/newsgroups.
    Can I join this survey?
  • wish i has byteode engine and more good framework.
  • For the last decade I thought that no language came close to Smalltalk, I was wrong. For large apps, multi-developer, Smalltalk is still better. anything else, I prefer Ruby
  • Keep up the good work!
  • no
  • Not for now... I'm just learning the language :)
  • I had skimmed the docs briefly for a few days. Then, I wanted to tackle a problem. I needed to process two files to produce a third. I needed to take a list of about 4400 students and delete from it those that were supposed to stay for post-term, so we could have a list of the remaining students who must checkout immeidately.
    Using Ruby and the HTML help, I had a working program in 5 hours--in only 3 lines of Ruby! I load & sort 1st file, load & sort 2nd file, and put the difference between the two arrays to a 3rd file. I've since been modifying the code to learn how to use modules, write methods that modify the receiver using "self", trace with the debugger, and more.
    This is cool, fun, powerful, and useful all at the same time.
    *Thank you, Matz!* (Dave and Andy, too!)
  • we are currently using it to "extreme-program" some prototype computational
    fluid dynamics (cfd) toolsets/frameworks
  • Didn't think I'd ever find something cooler
    than perl :->
  • Not yet, but this might chance.
  • not yet.
  • Ruby makes programming fun. A joy to use. My language of choice.
  • I'm new to programming and Ruby. I have learned basic Java and C before but am not good at them. Java is slow and bloated. C is really a headache because of it's syntax and it's rules are kinda confusing. And pointers really suck. ;-)
    I'm interested in programming and Ruby might just be THE language. ;-) I bought "Programming Ruby" and am reading it now. Hope to learn more and write some REAL code......
    thanks....
  • Thanks Matz!
    Ruby is absolutely great.
  • Thanks to Matz :-)
  • I'm blown away by Ruby. In the space of three months it has become my favourite language bar none.
  • Thank you all who contributed to the development of Ruby. Ruby is enjoyable to program in.
  • I don't think that those ugly "@" characters are really required from a language design point of view - Ruby code would look much better without the need for "@" prefixes. Also, I miss Python's ":" suffixes following "for", "if", "else" etc. statements - I find that they make code much more readable than without.
  • I find Perl and TCL so painfully abhorrent that I have been using ksh/awk despite its ugliness for the past ten years. Now we have to do more effective prototyping, so I have to find a better scripting language than ksh/awk. Recent media hype brought python to my attention, but a closer look at that language reveals it to be an ugly surficial hack designed by a programming language moron. Thankfully I found Ruby!
  • thanks
  • I think a mistake was made in trying to follow Perl's installation file structure. Perl's file structure is ugly, convoluted, and prone to error and misconfiguration. I don't have a better idea at the moment, but there must be one.
  • Oh yes, it would be nice if there were more precompiled binaries of the libraries out there.
  • The assumptions about the relative lengths of pointers and integers are not supported by the ANSI C standard. Among other things, this prevents use on 64bit machines.
  • Foo
  • Would like to contribute to build Win32 modules
    for admnistration purposes.
  • I wonder where the results of the survey are?
  • Great language!
  • The language I like to use most
  • yay ruby!
  • the ruby newsgroup is friendly and helpful. this is an advantage for a newer language
  • Best new language I discovered in the last 5 years! Thanks!
    The other language I which I liked very much and had partially helped implementing was EuLisp:
    http://www.bath.ac.uk/~masjap/EuLisp/
    Unfortunatly, the project seems to be abandoned.
  • Looking to see how Ruby can support (C++ STL-like) generic
    programming and Forth-like compiler extensions. I can see the
    trends but I don't know enough to determine how far it goes.
    The difference between brace delimited and 'do end' blocks
    is confusing.
  • I had just begun loving Perl when I met Ruby, and I am excited. Thanks to the creator and to the entire active Ruby community for providing such a fascinating development environment! (I can say this although I am still struggling with getting Ruby/Tk running under Windows NT 4.0.)
  • After 4 years of doing perl pretty exclusively, I have decided after writing my second ruby script, that I will never write another perl script.
  • I am still learning how best to use it.
  • Three cheers for matz!
  • Matz must be proud.
  • I think I would like the option of declaring
    the expected types (mix-ins) of method parameters.
    However, I love not HAVING to!
  • What is a good easy book on OO basics that will ease one into the elementary ruby books?
  • I love Ruby. I've almost stopped using Python entirely.
  • I have found Ruby to have one of the shortest learning curves of any language. When I introduced it to colleagues, they also got hooked with very little proselytizing on my part.
    The largest Ruby project to date is a 1200 line script that performs complete build every night, test, documentation checks, and exception reporting for our Java application. It would have been many times harder in Perl or Java.
  • Keep up the great work! This language deserves great success!
  • Great language. I hope it continues to grow.
  • Avoided getting too into Smalltalk, because it is fading. I really hope there is a future in this for full scale applications at large companies, but that is easier said than done. Trying to familiarize myself with Ruby and see where I might best throw my shoulder into the effort.
  • Ruby helps me get my jobs done much more quickly because I can actually automate my use of my computer.
  • Nope. Not at this time. I'm as happy with Ruby as can be. :-)
  • Can't wait for ruby to take over python!!!
  • A big thank you to everyone who helped create this gem of a language.
  • Too soon yet.
  • Thank you matz and the rest of the coders on ruby.
  • ruby -F- -e '$,
  • A better installation kit for Win might be nice. I developed some command line scripts and then I developed a Tk GUI - I wanted to then do the same thing with GTK - but I can't get the GTK to run. I probably need to play around with some config files - but it would be nice if I didn't need to (it's enough of a speed bump to make me stick with Tk for now). This is not a complaint - I realize it's my responsibility to get things working in my environment - but from a pragmatic point of view the more stuff that works out of the box the better. Especially for us command line impaired Windows users! ;-)
  • More fun than a programmer should have.
  • "1. How long have you been using Ruby?"
    This question may need some more options to answer, such as
    "1 to 2 years"
    "2 to 3 years"
    "Over 3 years"
    as I use Ruby since 1998.
    Or, how about asking the Ruby version one has first met.
    In my case, it was something like 1.2.x, if I recall correctly.
  • Wow! Sweet! Very cool!
    I can actually do something with Ruby
  • Thanks.
  • Excellent job - thanks
  • i love you all
  • CRAN !
  • The _Programming Ruby_ book is very good. Are there other books in the pipeline?
  • It's all good!
  • Like the language a lot.
  • The Ruby language is a GREAT language and matz and the community have done a great job. Support is great.
    One thing missing is a standard way of developing and managing development process. What I would like to see is the Ruby community adopt adopt a development methodology along the lines of Zope's Fishbowl approach (see http://dev.zope.org). Using this approach, community members can put forward project proposals, contribute towards design and development of current projects, follow discussions on development projects, etc...
    The Ruby community seems to be too scattered. We need more focus and communication on the development status of all RAA products.
  • I'm very happy to have come across this "gem" of a language. :)
  • i think this language needs to be popularized. as long as there are fewer people using ruby, very few ppl will think of developing reliable ruby scripts or migrating existing perl/bash scripts to ruby in a multi-programmer environment.
  • The operating system is called GNU/Linux, not Linux.
  • So far I have been very impressed, both with the language and the people who use/represent it.
  • Ruby is infectious and expressive.
  • Good job!
  • As a native Japanese I must say it is a shame that Japanese programmers are reluctant to use English in their docs. I think some constraints should be imposed for packages to be deposited in RAA, for example, at least provided with English README and unit test as seen in CPAN modules.
    I think It would be great for Ruby and Ruby community if some US company hire maz away from current post in order to make Ruby more useful than ever.
  • GREAT WORK !!
  • Don't like the requirement that the do/end
    {/} start at the end of the line:
    array.each do |item|
    puts item
    end
  • See question nr 6 about block syntax. I know you can use { } as well, even though I only have an idea about the difference I'm using def .. end since thats how all the examples look.
  • This is the first language I've looked at in a while
    that is really interesting.
  • RubyGarden is hard to navigate at first :)
  • Ruby is great language I hope someone's funding its continued development. I'd like to see it faster.
  • Dave and Andrew's book is superb.
  • We need more document, more examples.
  • Great language. I'm enjoying every second of learning it. The fact that the big people behind it is available for us mortals to interact with is a big plus. The whole ruby-community is a stable and enjoyable group of people.
  • Thank you to Matz and the Ruby community for their great work.
  • The Ruby community really stands out as friendly, pro-active and practical. Seeing Matz post regularily is great -- horse's mouth on-line!
  • I am hopeful that ruby will be able to be a useful addition to my tool set. I like the book! I hope more books are forthcoming from other authors/publishers covering more detail of the ruby language.
  • Please excuse the following, I felt like rambling, I realize some of the following aren't really useful
    I found the builtin Matrix stuff was a little irritating, how it declares "new" to be private and forces you to use it's "rows"/"columns" method to initialize it - it either forces you to conform to that interface for child classes, or use some sort of proxy if you want a more "normal" setup.
    With the builtin protocol classes, it would be nice to be able to get progress information during lengthly operations. Maybe be able to register a block that gets called periodically?
    I realize this would be difficult, but it would be nice to be able to call methods (or maybe threads?, modules?) with limited access. In particular, denying them access to things like ObjectSpace, and making runtime modification of basic things like Kernel/Object local to the method/thread/module. As well as the more "normal" permissions of network/file access.
    Oh, and while I'm t!
  • This is a beautiful language. I am glad I found it.
  • Ruby should run on Squeak. Many Squeak devotees love Ruby, but we have yet to see them integrate.
  • Good that you made this query. Thanks everybody!
  • Need more English books, and wizards! :-)
  • I would like to see an analysis on how Ruby compares with the concepts presented in the book Object Oriented Software Construction noting differences and similarities (and the resoning behind them) between the languages, tools, environments, etc.
  • Awsome language. The only think I use if I get to choose myself. Most of the time I don't :(
  • i can't read kanji :-(
  • Good that you made this query. Thanks everybody!
  • Just thanks to Matz and all who
    help the community grow and mature
  • Ruby is the coolest, most beatiful thing i've seen in a long time. i find the "principle of least surprise" to be wonderful.
    i haven't had this much fun programming in years.
  • It's hard to find ruby resources, even those things thatexist and are widely used don't seem to be indexed or accessible from an obvious place on the ruby-lang homepage.
  • Keep up the great work!
  • It took me a couple of days of study to start accomplishing real work. By contrast, I've been studying Java for about a month and still can't make it do anything but the most trivial stuff.
  • keep up with the good work
    Ruby rocks !
  • Ruby is great but there is still little community outside the web. In the Cologne area there are Linux, Perl and even TeX groups but no Ruby groups :-<
  • I discovered Ruby a couple of weeks ago by accident and love it!
    Can't say I like tk. Feels 'tacked-on' to me but I've not investigated it much yet TBH.
    I seem to be trying to learn a lot of new things at once: Ruby, OO, UML (not strictly neccessary but I need to put the OO in some context), Tk, Unit Testing etc. etc. I'd rather concentrate on one thing at a time but I feel it's important to have some grip on them all.
  • Yo keep the good work going
  • Have fun!
  • Ruby is probably the most enjoyable language out there today, and I can be useful in it, too!
  • Keep up the good work. It's one of the nicest language I've encountered, and I've already considered many OO and pseudo-OO languages
  • I would like to see Ruby's audience increase.
    But, I think people aren't really ready for another scripting language that is incrementally better.
    Ruby needs that "killer" marketing feature. (i.e. Perl
  • There seems to be a really good community around Ruby. That's a plus.
  • Keep up the good work!!
  • Thanks for all the effort the community puts into Ruby!

  • www.ezboard.com - is a Smalltalk venture that has shown tremondous
    success.Any thots on having Ruby work as OO front end to Smalltalk
    objects? - pardon if my ignorance is showing!
    Keep up the good work!
  • Needs more advocacy in some 'offical' or rather 'recognizable' form.
    Official web page should be updated more frequently than once/2-weeks so it looks like things are alive there and with Ruby in general.
  • I will publish Win32 extensions soon!
  • Just keep up the good work.
  • I *hope* to get a job developing in Ruby some day.
  • # ;)

  • a BETTER documentation in English (a tutorial, a reference and a library manual...) would be great !
  • the pickaxe book rules. i'd have to say the best programming book i've ever read.
  • I pursue the ruby news group gladly
  • Keep up the good work.
  • Keep up the excellent work. My only fear is that Ruby be destoryed by adding in useless features or features not in line with the design methodologies used thus far. Please keep it nice!
  • 1) Clean up the license.
    2) Compiler, please.
    3) Good work. Well done!
  • Props! I don't have anything negative to say about Ruby and don't imagine I ever will. Keep it up!
  • I'm impressed and encouraged by the rapid rise of Ruby; as we near the Great Cruft of Perl6, I feel time is running out before I'm forced to find a new general-purpose scripting language.
  • Definitly my favorite language.
  • This is the best language I've ever used.
    I'm definitely in love with Ruby. :-)
Things people like about Ruby:
  • It's fun! Because it's simple, powerful, and magic.
    What I like, and what I do can be found here:
    http://www.pinkjuice.com/ruby/
  • similar to perl without the defects (abstruse syntax, difficulty of
    building composite data structures or defining new classes, etc...)
  • It's very logic,
    it's easy
    and it's a lot of fun
  • sounds cool
  • best-of-breed dynamic OO language
  • The nice, clean syntax
  • THe fact it's the new kid on the block and is relatively obscure
    The pure Object Oriented nature. This makes it great for someone like me trying to learn Object Oriented programming without all the overhead of using C++ or Java when I want to try something small.
    Many of the great features of perl.
  • Best of perl, python, OO.
  • - full OOP
    - clean syntax
    - closures
    - irb
  • Clean syntax, complete standard library (never lack anything generic), lots of runtime information/manipulation about/of classes, methods and variables, easy and intutive to make generic implementation using iterators and Procs.
  • Powerfull and easy
  • It has a cool name.
  • Pure SmallTalk-like Object-orientation, consistency and orthogonality of language, built-in class library (like Java), all-around elegance, runs well on Unix.
  • More text manipulation power than AWK (which I've used for years) in a truly OO framework. Depending on what I need to do, I can write OO code or not.
  • The power, clarity and expressiveness
  • it's an easy language but untyped variable is so hard
  • It's SOOO very easy to learn. I learned Ruby in literally *one* afternoon, sitting down an reading the pickaxe book online. You can imagine the same is not true for the speed at which I learned Pascal, C, C++, Perl, Python, Java, or Lisp, all of which languages I am also proficient at.
    It's also interesting to note that Ruby is *fun* to program in. I saw this claimed a lot when I was reading about Ruby, but it's more than marketing. It really is fun! I don't know what it is about it, but when I program in Ruby, I think "this is really really cool."
    Ruby is very OO, yet allows operator overloading which is what I love about C++ and am annoying about in Java. Ruby brought everything good from Smalltalk/Perl/Python to the real, useful, world.
  • Clean, concise, elegant.
  • Clean, expressive syntax
  • I have never been fond of object-orienting. Instead, I have been more biased towards functional programming. However, the ease, flexibility and speed of Ruby development have proved to me that I remember more OO from university than I thought and that it actually can be useful.
  • It's clean, has a well-thought OO model.
    Its highly dynamic nature: open classes, singleton methods...
    True closures.
    Runs on every platform I care of.
  • easy to use, can focus on solving problems rather than building infrastructure.
  • Nice elegant syntax. A tidy structure with powerful methods and libraries. A well-thought-out implementation of features from other languages and new things that make Ruby special.
  • So clean, makes much sense, easy to work with, advantages of objects without all that Java clutter
  • Easy change from perl
    Much less spikey than perl/Tk
  • I like the "principle of least surprise" about Ruby. Also, the Ruby community is very helpful, and there are a number of resources available such as tutorials, documentation, and even free books!
  • "principle of least surprise"; its clean and efficient; programming makes fun, you start writing a script and end up with a couple of reusable classes
  • Mostly pure OO, flexible, practical, not too computer-scienceish. See Larry Wall's article on Perl as the first "postmodern" language - Ruby is the second postmodern language. Python is interesting, but modernist. I can write clean, maintainable real-world code without a lot of fuss.
  • Ruby is far more intuitive than Perl or Objective C or /* cough gurgle choke */ "AppleScript" -- with a few puzzling exceptions, you can go from concept to execution about as fast as you can type. Even bash is not that clean. Ruby is brilliant.
  • I think I like the avbility to get down to details, yet do it in a few statements.
  • The fact I really can read my own code after a month :)
  • first-class functions, continuations and bindings. powerful exceptions mechanic with wind-protection. pure OO model. variables as references. simple syntax. rich set of extensions.
  • True OO, unlike Python.
    Lean, unlike Java.
  • Clean syntax. Helpful people on ruby-talk.
  • pure OOP, elegent syntax.
  • The fully-OO syntax. The mark-n-sweep garbage collector. Closures. Iterators. Metaclasses. Operator overloading.
  • The way you can 'scratch and sniff' objects in irb. It just makes the whole object oriented thing a bit more concrete that you can on a whim ask an object what methods it supports.
    'each'
  • easyness of Perl, cleaness and structure of OO
    way cool
  • It is pure OO
  • it's red
  • Concise. Pure OO lang.
  • Pure OO thingy.
    I used to love Smalltalk some time ago, but now I'm completely in Ruby.
  • Its clean syntax and its simpleness in representing concept (call it its OO caracteristic or something else..)
  • Simple yet powerful, *very* easy to learn, encourages clean programming style
  • it's 'clean', versatile, powerful, and fun! scripts are written very quickly. ruby has some advantages to perl (e.g., OOP + multidimensional arrays without headache)
  • I simply can't find words...it's the greatest thing since sliced bread! :)
  • terse
  • simplicity. not a lot of syntaxtical overhead to master
  • Easy, OOP, Small, Fast!
  • It is very intuitive; Great community
  • OO features, iterations
  • 1. Clean syntax
    2. Particularly like CLU-like block callbacks
  • Fully OO
    Fast (should be faster)
    Integration with emacs
    clean design/implementation
    good for system-management, text handling
  • In some ways it looks like a better Perl than
    Perl, which is saying a lot more than many Ruby
    fans realize, I'm afraid. I vastly prefer its "real" scoping and its blocking constructs over
    Python's. Also, if you're going to be dynamic,
    you really should "go all the way".
  • It's powerful, elegant, and doesn't 'try' to be object-oriented, unlike some other languages.
  • Where Ruby really impressed me was in its thoroughly dynamic nature. It's a strong base language, and can be expanded very easily.
  • blocks,
    mixins,
    accessors,
    lots of stuff...
  • Ruby is more readable than Perl, and more expressive than Python.
  • Just about everyting... Terse, maintainable, powerful
  • *Clean Syntax
    *OO Designed in from the start (not an add-on like perl)
    *Built in threading (not an add on like perl)
    *Druby (Distributed Ruby)
    *Exceptions
    *Serialization built in, not an addon like in perl
  • Instant gratification - it's fun to try things out and immediately see what's what
  • I like the cleanliness of the language. After one weeks use I switched www.sf.net/projects/cheddar from c++ to Ruby. Within hours of making the change I had been able to create the output portion of the project. I like the flexibility, but I also like the order and structure of the language, as opposed to perl. I like the fact that I do not have write reams of support code to work with ruby.
  • Clean OO
  • Dynamic power of smalltalk, but easier to grasp for small, quick projects.
  • 1) consequent syntax design
    2) interactivity (irb)
    3) power of built in features (i.e file/IO class)
    4) OpenGl support,
    5) many useful Libs within Distribution
  • Very clean syntax. It does what I expect. Good OOP implementation. Quick development cycle. Fun to use.
  • The elegance of explaining the solution to a problem.
    The community.
  • fast development cycles
  • Writing a program is so fast!
  • OO paradigm
    closures
  • Guess what - I am a Smalltalker ;-)
  • Pure OO. Scripting's lack of tweak-compile-test-tweak cycle. Pure OO. Coherent vision/style/theme/principle of least surprise. Pure OO. Lack of type specifications. (Can you tell I've been fighting to write OO code in C++ for too long?)
  • language features
  • OO-ness with syntax cleaner-looking that Python.
    Blocks.
  • The active and friendly user community
  • Power, readability, flexibility, fast response to problems on Newgroups, and the fact that the pragmatic programmers have put their weight behind it.
  • Object oriented.
    Much easier to read than Perl.
    Many of the features of Perl that make it useful (regular expressions, network programming).
  • OO paradigm
    closures
  • Syntax is clean. Built-in objects and methods make sense ("string".length for the length of a string! Whee!). I also appreciate OO design and am thrilled as hell to find something that makes it so simple as Ruby does.
  • Pure OO language, simpler to use than C++.
  • Scripts are small; Perl/Smalltalk hybrid.
    Built-in threading model.
  • It is fast to create applications and class libraries, it is infinitely extensible and easy to learn and runs on many platforms.
  • yield and closures, reflection
  • Blocks
  • Friendliness in forums. Even the creator respond to "low level" beginners questions and comments. And very promptly too. Try that with f**ing Microsoft and you'll get a reply in two years if ever!
    As elegant as Smalltalk but more potential because Universities and such hasn't "found" Ruby yet. They did it with Pascal, then Smalltalk :-)
    Embedded regex.
  • Object-Oriented, Classes
    Array-Handling
    Extensibility
    Blocks as parameters.
  • "simple" syntax, typing
  • That it supposedly makes programming fun and easy.
  • pure objects
    powerful syntax
  • OO is easy, regex is easy, I don't have to worry about Perl's %/$/%
  • It's the most elegantly designed language I've ever used. Things make sense in a way that they don't for C++ or Perl.
  • The fact that the language makes sense and feels natural. Good community.
  • Closures. Beautiful syntax. Concision. And a small host of other things.
  • The very clean, very clear object orientation. The iterators.
  • Everything
  • The code is legible? ;)
  • 1) the name
    2) the people on the mailing list (respectful and quick replies)
    3) that it simultaneously replaces perl and python
    4) mixins and OO model
    5) extensions system/ API
  • It's the most elegantly designed language I've ever used. Things make sense in a way that they don't for C++ or Perl.
  • I can go from thinking about something to having a prototype in under an hour and I'm not even fluent yet. Its much higher level than java
  • Object purity
  • 1. support for collections (arrays, hashes, iterators etc.)
    2. simple file processing
    3. support for Regular expressions.
    4. properly OO, unlike Perl
  • Dynamic, pure-OO, clean syntax, RAA, pickaxe book
  • Doesn't force OO on me, but there if I want it.
  • OO, clean syntax
  • So far I really only know about the liner-note topics ('Everything is an object- no exceptions').
  • Elegance, power, terseness, simplicity, complexity.
  • Modern and **quick** approach to OO programming.
  • I'm really struggling with Perl (don't know where to look to find stuff) and everything belonging to a class *somewhere* helps me organize my thinking. Very dynamic.
  • I like that it has a simple readable syntax (except for those Perl-style system variables) and it a number of powerful and elegant features which makes it potentially a very useful language - and fun!
    Much of the things that makes Python one of my favorite languages also apply to Ruby.
  • 1) pure OO
    2) easy for people who know perl
    3) more dynamic than Java
    4) simple syntax
  • Loads of things - but particularly like the implementation of OO (it's so regular and consistent), the well-developed built-in classes and modules, and neatness things like using sigils to indicate scope.
  • The cleanliness and consistency. After doing OO in Perl, Ruby is a godsend :-)
  • The fantastic syntax, the way I can express my ideas in code very easily and quitely, and the elegant OO style.
  • the power and expressiveness
  • nice, clean language
  • * Interactive IRB module
    * Object Oriented
    * Less use of braces and semicolons and odd
    characters than Perl
    * Good manual - Programming Ruby
  • that it's Smalltalk-like (everythings' an object),
    the Eiffel-like syntax,
    iterators, the build in sytax-sugar (e.g. Python has no syntax for regular expressions...)
  • Nice object orientation.
    Lack of perl's ~!@#$%^&* operators and names.
    Don't have to predeclare variables (vs. python)
    Good built in library.
    Basically a more usable perl.
  • That it gives me Perl functionality but in a nicer form ( OO )
  • I like the concise syntax and dynamic nature.
  • The terseness and expressiveness of Perl combined with the elegance and strucure of Smalltalk. Wow.
  • It's fun.
  • Its smallness and its consistent, "cut-from-same-cloth" feel all
    the way through, together with the dynamicness of the
    language and many versatile, elegant constructs (such as
    iterators). Also the Ruby community, which is very accessible and
    helpful at every level of expertise.
  • Clean syntax, full oo, speed
  • Syntax, Class library.
  • Very clean, fun to use.
  • Conventionl syntax compared to smalltalk.
  • About everything.
    Having studied physics I'd like to say that it's very coherent (Laser like - Did you know that a _Ruby_-Laser was the 1st Laser that worked? Surely you did...)
  • It enables me to build on my knowledge of Perl, without needing to throw any of it away. Very little relearning is required, as everything that's great about Perl has been folded back into Ruby.
    What's really nice is that Ruby gives me a clean OO syntax into the bargain.
    I also like how many of the things that are extra modules with Perl are bundled with Ruby (HTTP, Tk, etc.). I don't need to go downloading too many modules to be able to do networking, etc.
  • It's cool and fast!
  • OO. script. fun.
  • to know about it more and more and more
  • fc
  • OO which is as usable as easy to understand and apply. it's almost joyful to program on it it feels like you want to do x, you think in how to do that(logic) not in how to implement it(actual code)what I mean it's that ruby grammar comes out naturally not like "U have to end each sentence with * and add BLAH BLAh here and there".Helps doesn't obstructs
  • similar to perl but OOP
  • First off, the friendly, helpful nature of the community/mailing list.
    I like the true OO approach, which is what drew me to python from perl. This seems another step in that direction.
  • Things tend to work the first time and
    its cleaner than perl.
  • It's simple, readable and yet complete and growable. It's pure OO a la SmallTalk, fast, easy to learn although harder than Python, possible to do procedural programming as well (hybrid) for small scripts. It's possible to change built-in classes, modules, etc.
    I could go on for the next two hours. There's actually very little, I don't like about Ruby.
  • object orientation
    ease of use
    power
  • Strict OOP
  • Dynamic, pure-OO, clean syntax, RAA, pickaxe book
  • It has borrowed and adapted the right features from Smalltalk, Perl, Scheme, etc. and has innovated just enough without ruining its simplicity.
  • It seems different enough from perl to be worth learning, and the ruby community seems a fun bunch of people.
  • It makes programming fun again.
    I don't feel like I'm working for the computer so much.
  • compact, expressive, dynamic, lots of libraries
  • Everything, so far! At first meeting, Ruby is elegant & combines all the features I have been looking for in a programming language.
  • - concise syntax, ability to do things quickly without a lot of scaffolding required.
    - ability to make simple procedural programs or more complex OO programs with same language.
    - great integration with win32 via win32ole.
  • Blocks
    Mixins
    better oo than Python (particulary encapsulation)
    easy to learn and use
    quick to write, but safe enough to leave in production code
  • fun like perl, clean unlike perl
  • - Elegance
    - Clean Object Oriented Language
  • Really easy to write correct code first time around. Also easy to read other people's code. Concise and readable
  • All its Perl-like features but with better object and exception support.
  • Better OO than C++, the language I wanted after deciding that speed was the most important thing in the world. (now it's OO and ease of programming)
  • Python like cleanliness, and program blocks.
  • - The "Ruby Way" !
    - clean syntax
    - OO model
    - no type prototyping
  • Simplicity and predictability. It combines the best of my favorite languages (OO, shortcuts, rich libraries), without forcing me to subscribe to some computer-scientist theory of how I am supposed to think. Ruby gets out of the way, making me feel like I am directly working with the problem, instead of having to grapple with "computer issues". It removes the nonsensical separation of code and data, and compile- vs. run-time decisions.
  • It looks very lovely. I *love* the ability to add methods to classes without subclassing. Never seen that before, but it's very intuitive.
  • Simplicity. Ruby is the first clear OO language for me.
    And the iterators are really really great thing.
  • Flexibility, true GC, extensibility, nice extension API, fun.
  • Seems like a cleanly designed OO language that has an easy to understand syntax
  • clear syntax, object orientation
  • What's not to like? Spectacularly easy to develop, especially using TDD. Generates extremely readable, simple, well-factored code. Intuitive. Fully OO. Closure support. *foo arg lists. I could go on...
  • Pure object-oriented language; Very intuitive; Runtime changes to classes, objects; Closures, proc objects, enumeration; Simplicity with which design patterns can be implemented
  • You can do a lot with a little.
  • I like the dynamic nature of the language and it's expressive power. It seems to have all the best features of the various programming languages in one.
  • cleaner than Perl while having similar features.
  • it's expressive, seems "natural"
  • Ive tried controlling the IE dom with vb and visual test before, and had very little success. In just a few days Ive managed a lot more with Ruby
  • Pretty much everything. Blocks, built-in patterns, almost everything is an object, easier to do quick hacks than in Python, easier to follow syntax than Python, etc.
  • That it's completely object-oriented. The iterators I definetely like.
  • Well, Java and C have way too much support code to write before getting to the meat. Perl is nice, but the OO is sad and the syntax is a little too much. Python is nice, but the module support is weak and the indentation feature could cause problems. Ruby has none of these problems! The thing that's great about Ruby is, a lot of languages largely grew from one previous language, attempting to fix the things that were wrong with it (i.e. C++ tries to fix C). Ruby doesn't do that, it takes the best parts of a bunch of languages and puts them together (well!).
  • Ruby is simple and still growing.
  • Best language in the world. Makes a lot of sense. Love those built-ins. Amazing.
  • oo-oriented structure, regular expressions
  • Everything
  • It is easier to write and read than Perl, due to its restraint with punctuation characters, and its does not make indentation critical as does Python. I like the fact that moderately complex data types are much easier to develop than in Perl and class variables are really private (unlike Python).
    Most of all, I enjoy the speed with which I could learn RUby and the enjoyment I get when I program in it. It often allows me to achieve "flow" - a delightful immersion in the design effort where I am dealing with the design space, not the language space. I always thought that engineering had much more to do with the creative responses to the problem being solved rather than virtuoso mastery of the tools being used. Ruby allows me to to more engineering in this sense.
  • Clean, efficient.
  • consistency and balance
  • Iterators, class lib, Smalltalk-ness
  • pretty much everything
  • very good, but lack good GUI and web framework, such as zope and wxpython in python
  • pure OO, clean syntax, regex, mixins
  • All is an object.
    I can rewrite java programs in half the code size with clearer concepts.
  • It looks more like Smalltalk. It does not need an image. Not a hybrid language like Java, everything is an object.
  • In my opinion, it's what Python thinks it is -- an OO language with the power of Perl.
  • - It's pretty high-level; lots of features.
    - Has regular expressions.
    - Easy syntax.
    - 100% object-oriented
  • Clean Syntax
  • good oo, clean syntax
  • the oo part
    perl like regexp's
  • It's fun! It is the most fun language I've used
    since I started playing with FORTH back in 1979.
  • More "real" OO than any other scripting language.
  • Looks like a nice replacement for Perl.
    Easier to understand and yet more powerful.
    Also easier to implement.
  • Clean design, powerful concepts
  • See http://www.hypermetrics.com/ruby37.html
    Beyond that, I am thrilled with how easy it is to use Thomas & Hunt's book (HTML help files) to learn how to use such a simple, powerful, useful language to actually accomplish real tasks. Native RegEx is a great plus.
  • It has a large amount of "whipupitude". And it's so easy to learn.
  • It's simplicity and consistency.
    The fact that it remains beatifull and uncluttered despite all the syntactic sugar. Good sugar!
  • clarity of expression
    object oriented
  • Simple syntax, Full OO-ness, Principle of Least Surprise, Easy to extend, Dynamicness
  • OO, everything is an object, blocks/iterators,
    regexps, clean syntax
  • It's clean and coherent.
  • Give me one more month to answer this. Hopefully Japanese Information Processing will be easier than in other languages-
  • Um, well, since I havn't used it...I donno!
  • procs
  • intuitive syntax
    pure object oriented
    rubyUnit
  • Very clean design without mandating to the user
    how it should be done. Also willingness to borrow
    useful ideas.
  • Don't know yet. I'm new to it.
  • The OO nature. Simplicity, power, and elegance.
  • Strict object-orientation
  • It's hugely powerful, but not at all taxing to write in.
  • It's clean *and* powerful. (Clean languages tend to be poor in power; powerful languages tend to be messy. Ruby is a rarity.)
  • closures, reflection, conciseness.
    built-in regex support. :)
  • Takes best of Python and Perl and has advanced
    OO features (and, finally, a case statement!)
  • Extremely clean design. Excellent C interface. Reasonable time,space performance. Viable cross-platform support (eg., unlike Java). Takes the best ideas from modern programming language theory and makes them into a practical scripting language. I especially like that someone *finally* enforced variable naming conventions in the language itself (eg., @global, local, CONSTANT).
  • its nice
  • very readably, intuitive
  • Pure OO without being obtuse; has all of the best features of all of the best languages, IMO.
  • Power and Elegance. Very Sweet
  • It reminds me of Squeak, I love Squeak!!! but it's a bit more practical.
  • The strictly object based approach and that it is hidden. I am no True Believer in OO, but in Ruby it helps to find information about classes quickly. Much faster than in Perl or Python. Some interesting control features (retry, for instance) as well.
  • We will have to see.
  • oop integration, easy syntax, can be more powerful than perl or python.
  • very clean design. oo library easy to grasp. blocks are just plain cool.
  • The syntax. Its new. Its exciting. It surprised me because of so much can be done in so little space. I don't like it, but I do love it.
  • Strong OOP
    Easy to create threads
  • powerful, simple, OO, pretty portable, dynamic
  • easy to write extension
  • Sweet OO-ness, lots of new things for me to learn. i feel more powerful as a programmer just writing things in ruby.
  • Whole concept, I already tried to design really object oriented language (with more like lisp syntax) then I found ruby. From languages I know (about 10) I like ruby most, but implementation issues such as speed, force me to not use it always.
  • the similariteies it has to perl
  • ruby > (perl + smalltalk) / 2
    I used perl for everyday problems. Now I will use ruby.
  • Relatively clean language design.
    Clean look.
    Nested data structures work exactly the way I expect,
    unlike TCL and Perl!
  • Readability (and hence maintainability).
    Powerful, concise, clear syntax.
  • object-orientedness; features inherited from Perl and Lisp; dynamically typed; interpreted
  • elegancy, fast prototyping, introspection.
  • Readibility, OO, code reuse, rapid devolpment, clean syntax.
  • Similar to perl, but actually is OO
    very clean structure & syntax.
    high level and low level at the same time.
  • Pays homage to the best parts of perl and python
    within a clean, consistent oo framework.
  • Simplicity. Flexiblity. Blocks.
  • The wide number of extensions which are already available - graphics, distribution, Tcl/Tk etc.
    I have found it very easy to build my own extensions from C++ classes using SWIG.
    I am interested in symbolic algebra programming. I have previously interfaced my C++ codes to Tcl and the interface with Ruby is much better. I can write
    z
  • Fully clean OO
  • Combines the best of scripting languages with a clean, powerful object model.
    Extensibility in C.
    Excellent community.
    Freely available and open source.
  • Ruby seems at first glance to be a language with good 'proportions'. Pure yet practical and pleasing to look at. Ruby is still young, but she might grow up to be strong and beautiful if we the programmers allow her shine,... elegantly.
  • freedom like Perl
    good OO structure
    code blocks
  • everything
  • Just about everything.
  • The similarities to Smalltalk, Perl and Python.
  • Dynamicness, ability to add things to the system easily.
  • It has most of the features I loved in Smalltalk but with a much friendlier and readable syntax
  • Elegant, orthogonal object model. Simple syntax. Adheres to the "principle of least surprise" surprisingly well.
  • Consistency in language and class design. Block iteration on objects (each).
  • I'm still not quite finished with 'Programming Ruby', and I haven't actually used it yet, but here are my initial impressions:
    1. Consistency. Everything works the same way. The features fit well together. This is a tremendous achievement.
    2. Code blocks, closures. These are indispensable, and things like the File.open .. end feature are real time savers, in addition to increasing safety. Iterators are excellent.
    3. Kernel. It's great to be able to get into the guts of the system easily and consistently, to configure behavior of the application as a whole, without having to modify the interpreter in C.
    4. Modules/mixins, and the similarity between them and classes. Single inheritance with mixins is a great way to do things.
    5. I experiment a lot, so I like the fact that I have all the options when it come to control flow: try/rescue/ensure (with retry!), throw/catch, _and_ continuations![
    6. Sometimes threads just need to be killed. I'm glad Ruby doesn't follow the current trend of 'protecting' us from doing this sometimes necessary thing.
    7. Sensible C API.
  • that it is pure oo.
  • Syntax, iterators, simplicity, 'glue' ability. Great resources: comp.lang.ruby, Fulton's Ruby Way book, Win32 install package, PickAxe book, class ref @ rubycentral, PLEAC-Ruby.
  • changing class definitions, object behavior in running systems is sweet.
  • Ruby's OO symantics help me to develop very
    well designed and clean programs very quickly.
    I also find the iterator methods very easy to use and develop with.
  • It's truly object oriented in the smalltalk sense and extremely utilitarian in the perl sense.
  • It's a real language
  • At the moment: all
  • Real OO, Do things the easy/fast way. Fetures from perl
    iterators, blocks, easy c-interface.
  • It's very accesable. I'm new to programming and its easy but clean syntax helps me out quite a bit.
  • It's correctly OO, concise, got a good interface to Tk and PostgreSQL.
    Lots of work in few lines of code.
  • The general way it makes me program. When I code ruby my programs are so much clearer than my C++/perl.
    Specificly I like iterators, Objects and the way I can always say
    a_var
  • Fully object oriented
    Closures/Iterators
    Good class library
    Very productive
  • small footprint. play w/OO, i love perl, but
    perl's OO is cumbersome at best. i like ruby
    because it is perlish enough to be familiar and
    different enough to be interesting to learn.
  • It's object oriented nature - I seemed to be able to get up to speed quickly as opposed to a few false starts with Perl. I was considering Python as my scripting tool of choice but then a friend told me about Ruby. It's been Ruby ever since
  • Very high level
    Easy to read
    Expressive
    Interpretted
  • It's intuitive.
  • * Design philosophy ("maximize the fun to code")
    * Easy to learn/write/read
    * Eficient for text processing, with full support for multi-byte text.
    * Skillful and active user community
  • Simplicity and extensiblity at the meta level
  • Object-oriented, readability, blocks, iterators, API for embedding/extending Ruby
  • True OO.
    Smart design.
    Simple.
  • it's fully oop compliant
  • clean; pure OO
  • It's beautiful, and fun! Within minutes of scanning "Ruby in a Nutshell" I was able to whip up incredibly simple scripts that would have taken considerably more coding in any of my other languages of choice (Java, C/++). Highly intuitive language.
  • Clean syntax / expresssiveness / call-blocks
    Fully OO
    general ability to get things done easily
  • it's cool, borrows a lot from Perl
    (perl is very fascinating),
    clean OO model, easy to understand and use
    "perl done right"
  • no comments, still learning!
  • Full/Clean OO, Garbage collection, no compile cycles. I especially like Mixins
  • Free and powerful like Perl.
    But cleaner...
  • iterators, its simplicity and the syntactic sugars.
  • Pure OO (even with all of the extras to make it Perl-like).
    Consistent language paradigms (such as use of blocks, which is another big plus in and of
    itself and iterators); once you understand these programming in it is fairly easy.
    Built in data-structures (arrays and hashes) which are extendable (which goes back to the OO).
  • Clean
  • Nice, clean syntax. Strong OO principles. Appears to have a nicer design than Python, which I have a limited amount of experience with.
  • Syntax, Objects, cute name.
  • Powerful.
    Simple.
    Logical.
  • Extremely clean appearance of code. Super simple OO implementation (compare kludges like C++ and Perl). Young vibrant language and community (especially true for English speaking places).
  • concise syntax
    OO features
  • Pure object orientedness
    Clean implementation
    Elegence of Ruby language
    Easy to learn and program
  • it's a clean and elegant language. I can do things in very short pieces of code that really perform quite a lot of work. There are very few "funny characters" in my programs other than regular expressions (the kind of garbage code that characterizes perl, making it a nasty write-only language unless you're very careful.)
  • OO, fast, compact
  • Hmm, everything!
  • Concepts easy to understand, programming in Ruby is very comfortable. Helpful and friendly mailing list.
  • It provides better data model than Perl,
    and at the same time doesn't lose any of
    Perl's strong points (as Python unfortunatelly does).
  • - simple to get 'up and running'
    - clarity and consistency of semantics and syntax
  • The uniformity of everything being an object.
    Code blocks.
    Syntatic sugar of not having to deal with "self" everywhere.
  • Easier to grok than python.
    very clean.
  • Ruby is very flexible. Mostly. It's got a good object-oriented flavor, and most nitty-gritty stuff is pretty well automated.
  • The beauty of the language.
  • It's small and intuitive.
    The OO paradigm is pervasive.
    It's fun to program.
  • It's a domestic production.
  • Its clean internals, cool syntax and pure OO
  • Object-orientation. Blocks. Dynamic nature.
  • Its pure OO architecture, regexp support and general ease of use
  • coherence, elegance, design
    the community, the available libraries
  • flexibility, ability to express myself quickly
    and easily, the ability to get stuff done
    quickly, and yet still have readable, maintainable code
  • pure OO, easy syntax, looks like a mixture of Lisp and Smalltalk
  • Very clean
  • Iterators, mixins (even though I haven't written one yet, I _know_ I'll find them elegant and useful), the whole thing (except the def .. end-syntax, that makes it difficult to find the start of the block in vi).
  • Almost everything.
  • Conceptually clean and a lot like smalltalk with
    perl's re.
  • It's so dynamic, and its syntax is very clear and intuitive. I can achieve a lot in a single line. And I can tell it what I want it to do, I don't have to coax it with unnecessary declarations etc to get it to cooperate!
  • The language features are well designed.
  • The Smalltalk feeling. I even think that Ruby is a better and more organized Smalltalk.
  • It's pure OO concepts and beautifully clean syntax
  • It's compact, yet easy to read syntax and pure Object Orientation definitely make it a best of breed language in my mind. I intend to find uses for it wherever I can.
  • That it is simple to write small scripts, but not limited to that.
    The pure OO feels great, too.
  • Very natural expression of algorithms within the language. It's like you're writing a description of what you want to do but that's actually the code.
  • clear simple syntax
  • Readability, ease of use, dynamic typing, speed of implementing stuff
  • It's too early to really tell!
  • The huge class-library, and the nice ruby-users that always provide help when i need it.
  • pure OO
  • was easy to learn.
    portability.
    being able to control COM object was what made me buy the Pick Axe book. It is a clean language.
  • Advanced features. If c++ was a 1980 language,and Java is 1990 then Ruby is 2000.
    Things I like
    -cross-platform
    -GC
    -built-in threading
    -dynamic lang features & reflection
    -a fairly good set of libraries (I'm quite excited about FxRuby for Fox)
  • The syntax, availability of documentation and help.
  • The thing I like most about ruby is that there are no constants per se, but that everything is an instantiated object. I also like it's clear and coherent syntax, and it's lack of difficult to master punctuation.
  • Real OO lang. Dynamic. Makes sense out-of-the-box.
  • It's easy, comprehensible, very fast to play with ideas. It seems less "fragile" than other languages I've used, and the 'POLS' design makes most things quite nice.
    Also, it's a smallish download, and simple compile (esp compared to python/perl).
    I love that "require" failures can be caught, lets me do nice things like use a compiled lib if its there, interpreted if not, or pick appropriate UI's based on available libraries.
  • Iterators. Pure OO. Clean expressive language.
  • Very expresive (e.g. blocks)
    Open Source
  • Pure OO is so much fun, I sometimes cry. I spend my night programming in this beautiful language now.
  • GREAT SYNTAX!!! If you write a program in Ruby, IT WORKS. PERIOD.
  • The language, the community, the openness.
  • concise syntax, iterators, useful file/regex/array/string functions, very useful networking libraries
  • Shallow learning curve ( so far )
    Things that should be easy to do, seem to be easy to do; unlike C, where even some things that should be
    easy to do have you jumping through hoops.
    I guess to put it simply, i like the marriage of power and ease of use.
    Oh yes, and less tying involved.
  • The high level of pure object-oriented concepts implementation.
  • iterators and block, fully OO, got the best parts from perl/smalltalk/lisp, threads, easy-to-use C-api
  • perl brevity combined with python readability
  • Its simple syntax, its natural and powerful string class.
  • * Balance of simplicity and features.
    * Clear and understandable implemntations
  • The language, the community, the openness.
  • concise syntax, iterators, useful file/regex/array/string functions, very useful networking libraries
  • not sure yet
  • genuine OO, lots of good ideas from Perl, and the fact that after 2 weeks I feel Ok with it, and in a month I hope to become an expert.
  • cleaner than perl
    easier to do clean OO development
    VERY high level, complete applications in very few lines of code
  • pure oo. I've been a perl hacker for several years, but it just doesn't scale well. Am looking for an alternative.
  • It makes me extremely productive. OO concepts built in from the start. Code blocks and iterators make for highly readable code.
  • Small language, reasonably powerful, simple, excellent for scripting.
    I think the block/iterator structure is very elegant.
  • blocks/iterators and open classes
  • I'm not sure this makes sense, but I'll try to explain it: I've always hated Perl's alleged object-oriented features, and Java makes everything ridiculously complicated. Ruby doesn't get in the way of getting work done.
  • completly object oriented
    high level programming
    principle of least surprise
  • pure object orientation approach
  • Pure OO, Multi-thread
  • Its simple yet powerful OO model.
  • better for complex data structures than Perl
    better OO than Java (by far!)
    principle of least surprise
    dynamic typing
    open source
    Matz is a cool guy!
  • Ruby does what I expect it to do. Nothing less but (which is more important) nothing more.
    Code is readable even after quite some time.
  • Clean
  • I finally *get* OO.
    Easy to get into; it encourages experimentation.
    Fun.
    Can learn a lot very quickly. Has a gentle learning curve.
  • Its clean appearance and the ease you
    have in understanding code sequences you
    wrote "ages" ago.
    OOP
    Closures ...
  • It's lightweight, elegant and intuittive. Has a very clean OO model
  • You can type what you mean for it to do without typing lots of extra syntax. It's very clean :)
  • Pure OO makes it very consistent and intuitive to use. Nice syntax. Cross-platform. Great languages create great communities. The rubiness of Ruby :-)
  • * its clear and simple syntax
    * its approach to object orienting
    * how it lets you enhance the language itself
  • -readability of the code (far away from perl)
    -easy to use and understand
    -lightweight in comparison of java for example
  • http://www.pinkjuice.com/ruby/rmmfg.txt
  • OOP features of the language, friendliness of the community
  • - "pure" OO
    - fast
    - mixins
    - open source
  • OOB Iterator
  • It's easy to get things done quickly with Ruby since it doesn't get in the way with unnecessary details.
  • the object oriented style
  • This is my third day of using ruby. Previously, I had only used C and Java (and a bit of scheme), and with ruby I am already far more productive than with those languages. I like the ruby syntax, much less typing than with Java. Code blocks are cool, as is the regular expression support. Good libraries, too.
  • Seems very clean and easy to learn. I like the iterator and block codes - though I have to admit that I still haven't wrapped my head around the full potential of this...
    I enjoy the community's friendliness.
    Also I have to admit that I chose this over perl because I was frightened by Perl's crypticness... though my friends are now berating me for skipping Python.
  • That "everything is an object" as in Smalltalk, but there are controll-structures and Regexp, Hashes to make programming more effective.
  • So far I like everything. Maybe the very best feature is RubyCocoa. But the language just makes sense.
  • It's what Perl and Python should have been.
  • simplicity
  • I like its consistent design and the many great language constructs (iterators, closures and so on) I always missed in other languages. It's especially useful, that Ruby provides all modern language features in a single interpreter.
  • OO-ness. Blocks. Community support.
  • Simplicity
  • It perl orgins.
  • Cool and flexible
  • OO at your fingertips
    Clean syntax
    Convenient...what you expect is there
    Complete, but non-overwhelming standard library classes
    Perl-like regular expressions
  • Clean syntax.
    Pure Object-Orientation.
    Incorporation of several good ideas from Eiffel.
    Concise yet readable.
    Functional aspects.
  • incorporation of the best from the best lamguages
  • It doesn't surprise me.
    No irrational and gratuitous punctuation marks needed.
    Succinct, yet not crytpic, syntax.
    It's readable!
  • True OO, expressiveness and flexibility
  • Complete OO & code blocks. I am also fond of some of the patterns that appear to be builtin to the language.
  • It's dynamic. It's fast enough. It's easy to write. And I like the ``Programming Ruby'' book.
  • no surprises. even large programs/changes often run at the first try.
  • pure OO
  • clean syntax
    objects
  • -dynamic typing, no more 'public static final String' , arggh!!
    -no more compiling!
    -finally, _everything_ is an object!! (in java: everything is object, except for x,y,z)
  • the best oo scripting i know.
    no troubles with size of integers.
  • It is intriguing on the surface.
  • It's a very clean, well thought out language. It is very enjoyable to work with.
  • Easy to learn!
  • Consistent OO, Clear, very fast development.
    The perl, i dreamed of.
  • It's design is elegant and relatively pure. I've used a lot of different programming languages and I'm moving almost EVERYTHING to ruby because of it's design, simplicity, features, and intuitivness.
  • It appears to be more like the way I wanted to use Perl. I get exceptions, pattern abstractions, all the benefits of Python and Perl while wrapped in a syntax that is less prone to stupid errors.
  • - 'Pure' O-O
    - High level
    - Fun :-)
  • the clean OO approach
    iterators (I wish C++ had such an easy to use
    "each" (sigh!))
  • Interesting as a fully object-oriented language.
    Curious about blocks and iterators.
  • Very easy to learn.
    Developping in Ruby is very quick and easy (and pleasent).
    Very efficient for writing network application (good API, threads, ...)
  • It's so intuitive, well-thought, easily extendable
    (i LOVE the idea of class reopening ...