Slashdot Mirror

An anonymous reader writes: Ruby developers have announced the official release of Ruby 2.3.0. This release introduces a frozen string literal pragma, which is "a new magic comment and command line option to freeze all string literals in the source files." It also adds a safe navigation operator &. similar to what exists in C#, Groovy, and Swift. Ruby 2.3.0 also has many performance improvements. For more details, see the news file and the full changelog.

An anonymous reader writes: Ruby developers have announced the official release of Ruby 2.3.0. This release introduces a frozen string literal pragma, which is "a new magic comment and command line option to freeze all string literals in the source files." It also adds a safe navigation operator &. similar to what exists in C#, Groovy, and Swift. Ruby 2.3.0 also has many performance improvements. For more details, see the news file and the full changelog.

Today marks the release of Ruby version 2.1.0. A brief list of changes since 2.0.0 has been posted, and file downloads are available. Here are some of the changes:

• Now the default values of keyword arguments can be omitted. Those 'required keyword arguments" need giving explicitly at the call time.
• Added suffixes for integer and float literals: 'r', 'i', and 'ri'.
• def-expr now returns the symbol of its name instead of nil.
• rb_profile_frames() added. Provides low-cost access to the current ruby stack for callstack profiling.
• introduced the generational GC a.k.a RGenGC (PDF).

Today marks the release of Ruby version 2.1.0. A brief list of changes since 2.0.0 has been posted, and file downloads are available. Here are some of the changes:

• Now the default values of keyword arguments can be omitted. Those 'required keyword arguments" need giving explicitly at the call time.
• Added suffixes for integer and float literals: 'r', 'i', and 'ri'.
• def-expr now returns the symbol of its name instead of nil.
• rb_profile_frames() added. Provides low-cost access to the current ruby stack for callstack profiling.
• introduced the generational GC a.k.a RGenGC (PDF).

Today marks the release of Ruby version 2.1.0. A brief list of changes since 2.0.0 has been posted, and file downloads are available. Here are some of the changes:

• Now the default values of keyword arguments can be omitted. Those 'required keyword arguments" need giving explicitly at the call time.
• Added suffixes for integer and float literals: 'r', 'i', and 'ri'.
• def-expr now returns the symbol of its name instead of nil.
• rb_profile_frames() added. Provides low-cost access to the current ruby stack for callstack profiling.
• introduced the generational GC a.k.a RGenGC (PDF).

An anonymous reader writes "For many of us our hosting providers are a way to hone our skills as well as run a business. Which provider out there gives the best bang for the buck for a FOSS developer? Virtually everybody provides Perl, PHP, Ruby, MySQL / MariaDB etc. but where can one get easy and cheap access to a stuff like NodeJS and Big Data? Companies such as Pair Networks are great but not quite on the mark with any of their service offerings for somebody looking to test out real world scenarios with these technologies from a hosted stance. Obviously hosting from home is always an option but that has the penalty of administration, backup, DR planning, bigger security footprint etc. and for those of us whose time is balanced between making money and friends / family time that's not very appealing."

An anonymous reader writes "Today version 2.0.0 of Ruby has been released. This is a stable release, and the Ruby team has done their best to make it compatible with 1.9, making it easier to migrate than it was to switch from 1.8 to 1.9. New core language features include: 'Keyword arguments, which give flexibility to API design; Module#prepend, which is a new way to extend a class; A literal %i, which creates an array of symbols easily; __dir__, which returns the dirname of the file currently being executed; and UTF-8 default encoding, which make many magic comments omissible.' There are also new built-in libraries for lazy stream and for an asynchronous exception handling API. The release includes a number of performance improvements and debug support for DTrace."

ruphus13 notes a six-pack of serious vulnerabilities discovered in Ruby by a member of Apple's security team, Drew Yao. Patches are linked from the ruby-lang.org advisory. "With the following vulnerabilities, an attacker can lead to denial of service condition or execute arbitrary code... These vulnerabilities are likely to crop up in just about any average ruby web application. And by 'crop up' I mean 'crop up exploitable from trivial user-specified parameters.' It's not hard to begin imagining cases where Ruby/Rails programmers use code similar to the samples above to routinely handle user input."

Tim Hunter writes "Hal Fulton's The Ruby Way, Second Edition doesn't try to be the only book a Ruby programmer needs. It tries to be a book every serious Ruby programmer needs, and it succeeds. The Ruby Way is a book about programming with Ruby, the object-oriented programming language from Japan. Ruby is free software and runs on Linux, Microsoft Windows, Apple OS X, and other operating systems. It is available for download from its web site, www.ruby-lang.org or its companion site www.rubyforge.org. Read the rest of Tim's review. The Ruby Way, Second Edition author Hal Fulton pages 839 publisher Addison-Wesley rating 9 reviewer Tim Hunter ISBN 0-672-32884-4 summary A task-oriented book about the Ruby programming language

I read the first edition of The Ruby Way when it was published in 2002, not long after I starting programming in Ruby. I was a member of the discussion group Fulton organized during the writing of this edition. I am also the author of RMagick, one of the libraries described in this book, and did the technical review of that section.

This is a review of the second edition of The Ruby Way. The first edition described the then-current Ruby syntax and libraries and showed novice Ruby programmers how to perform common programming tasks. In the past four years Ruby has evolved and its community has grown immensely. Consequently, the first edition was starting to look a little long in the tooth and the Ruby community has been eager for the appearance of a new edition. This edition is almost a complete rewrite. Saying that it's 260 pages longer minimizes the actual scope of the changes. There are a dozen new chapters. Some of the new material expands on topics that were present in the older work, like regular expressions and data structures. However, much of the new material covers topics that simply didn't exist 4 years ago, such as Ruby's XML and RSS libraries, RubyGems (Ruby's answer to CPAN), and Rake, the Ruby version of make.

The Ruby Way doesn't try to teach how to program in Ruby. For that, you need Dave Thomas' Programming Ruby: The Pragmatic Programmer's Guide or a similar book. The goal of The Ruby Way is nothing less than describing the universe around the Ruby programming language. In one 800+ page volume, it describes Ruby's design principles, history, syntax, built-in classes, standard libraries, 3rd-party add-on libraries, related development tools, and user community. The examples and Fulton's explanations emphasize Ruby programming best practices, hence the title.

Fulton describes The Ruby Way as an "inverted reference." A typical reference book for a programming language lists the libraries, classes and methods by name, which you can use to discover their purpose. The Ruby Way, on the other hand, groups Ruby's libraries, classes and methods by purpose, from which you can discover their names. Section titles tend to describe tasks, such as "Tokenizing a String" and "Interacting with an IMAP Server". The sections then describe the split method in the String class and the net/imap library, respectively. Several chapters group Ruby libraries by related tasks. For example, Chapter 15 describes Ruby libraries used to process specialized data formats such as XML, RSS, images, and PDF. In this chapter you will learn that XML processing in Ruby is typically done with REXML and that PDF files can be created with PDF::Writer, etc. Organizing topics by purpose or function instead of by name makes it easy to discover what parts of Ruby you need to complete a task.

Unlike many of the 2-inch thick books about programming for sale lately, there is no fat in The Ruby Way. It hits the ground running with an introduction to object oriented programming and a whirlwind tour of Ruby syntax. It covers Ruby's built-in classes in considerable depth. The String class gets an entire chapter, as do regular expressions. Array and Hash rate yet another chapter. Fulton continues with an in-depth survey of Ruby's extensive standard library. Interested in object persistence? Chapter 10 describes Ruby's YAML library. Wondering about unit testing? Go to Chapter 16 to read about the Test::Unit library. One of the most frequently asked questions to the ruby-lang mailing list is "what GUI libraries are there for Ruby?" Chapter 12 supplies sample applications that demonstrate graphical interface libraries such as Ruby/Tk, FXRuby, and QtRuby. Chapter 19 is dedicated to web application development tools ranging from the famous Ruby on Rails to the lesser-known but equally useful Nitro. Chapter 22, "The Ruby Community," tells where other Ruby programmers hang out. Catering to his programmer audience, Fulton peppers each section with code snippets and complete example programs. (The source code for the book can be downloaded from Fulton's web page.)

Although Ruby is thought to be a "Linux-centric" language it also has a large audience in the Microsoft Windows community. Fulton addresses these users' needs with a description of the "One-Click Ruby Installer" for Windows. This description is accompanied by a section about the Ruby libraries available for scripting on Windows. For example, Fulton shows how to open a file dialog box using the Win32OLE library.

Fulton says that he doesn't expect anybody to read his book from front-to-back. Nevertheless The Ruby Way is quite readable and (if not for its considerable weight) would make a good book for browsing while waiting for the bus, or between classes. Some sections contain a surprising amount of general background information, such as the remarkably in-depth description of Unicode in Chapter 4. Not content to simply educate the reader, Fulton continues his practice in the 1st edition of entertaining the reader with thoughtfully chosen quotes, geek humor, and personal observations.

Is there anything not to like about this book? Well, to be perfectly honest I occasionally found myself wondering if sometimes Fulton spread himself too thin. The amount of coverage for individual classes and libraries varies widely. Some of the standard libraries, like REXML, get several pages of description and an accompanying example while others, such as open-uri, get only a cursory introduction and a pointer to the on-line documentation. At 4 pages, the section on Rails is perfunctory and, given the number of very good books already available on the subject, redundant. (Fulton himself says the material is "cursory.") I have to wonder if it isn't there simply because "everybody" expects books about Ruby to say something about Rails. Similarly he devotes a single page to ActiveRecord, which, as a part of Ruby on Rails, is capably documented elsewhere. That page would've been better used to double the number of pages spent on Og, another Ruby ORM which is not so richly documented.

I recommend this book to any programmer who has already learned the basics of Ruby syntax and its built in classes and who wants to learn more about using Ruby to accomplish typical programming tasks. While it will be particularly useful to the novice Ruby programmer, it is a handy reference for Rubyists at any level of experience.

You can purchase The Ruby Way, Second Edition from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Simon P. Chappell writes "This may not be the book that you think it is, if you don't read the title carefully, but it is the book you need, if you are developing applications for Ruby On Rails (often known as just Rails, or RoR, to its friends). When learning any new development platform, there are many idioms and approaches, best practices if you will, that can benefit your development efforts. This book sets out to bring you that understanding of the best way to write the Ruby side of your Rails application." Read the rest of Simon's review. Ruby For Rails author David A. Black pages 493 (17 page index) publisher Manning rating 10/10 reviewer Simon P. Chappell ISBN 1932394699 summary A stunningly well written explanation of real-world Ruby skills for Rails development.

I see two main audiences for this book. The first group would be those who are learning to develop Rails applications and need some help with their Ruby skills. The second group would be those who already have good Ruby chops, but who want to learn the primary Rails idioms and techniques. Naturally, there is always the curious geek crowd who might find the twofer of an introduction to writing real-world Ruby and a hype-free description of what Rails actually brings to web development, to be quite attractive. I place myself firmly in the third group, but after reading this book, I'm ready to move to the first group.

To quote it's own website, "Rails is a full-stack framework for developing database-backed web applications according to the Model-View-Control pattern." The first thing this tells us is that like any framework worth it's salt, it is fully buzzword compliant. The second thing it tells us is that it really does try to help with every layer of your application, from providing a full controller to automatically mapping your data objects to their respective backend database tables. Oh, and with the bare minimum of configuration files to boot! For those of us who have developed web applications with Java, this is a welcome break.

The first part describes "The Ruby/Rails Landscape" and has three chapters that describe how Ruby works, how Rails works and then shows a very simple example of Ruby-enhanced Rails development.

The second part describes "Ruby Building Blocks" spanning five chapters, four through eight. This part is a very good tutorial style introduction to Ruby. Chapter four introduces objects and variables with chapter five showing how to organize those objects with the concept of classes. Chapter six introduces us to modules and program organization in general. Chapter seven talks about the default object, self, and scope. Chapter eight covers control flow techniques. This is more than just a fancy way of saying conditionals and loops, because it includes one of the better explanations of closures that I've read to date.

The third part describes "Built-in Classes and Modules", in chapters nine through thirteen. Chapter nine covers some of the Ruby language essentials for Ruby development in the trenches. These include useful syntactic sugar, the family of methods that change data "in place" rather than returning a modified copy, some of the tricky aspects of the Boolean objects and the proper ways to compare two objects so that you get a comparison on their contents, which is likely to be what you want, rather than their memory location. Chapter ten looks at scalar objects: strings, symbols, numbers, times and dates. Chapter eleven examines the Ruby collections: arrays and hashes and discusses when you would use each one, based on their relative strengths. Chapter twelve looks at the regular-expression facilities within Ruby and chapter thirteen wraps up our tour of Ruby with some of the dynamic aspects of the language, including the "eval" family of methods that allow a Ruby program to run arbitrary code.

The fourth and final part describes "Rails Through Ruby and Ruby Through Rails". To quote the book, the purpose of the fourth part is "helping you get more out of Rails by knowing more about Ruby." To this end the simple application created in the first part of the book is revisited and revised. Chapter fourteen starts us out with remodeling the application written back in chapter three. Chapter fifteen looks at programmatically enhancing ActiveRecord models. Chapter sixteen covers the options available for enhancing the controllers and views. Finally, the part wraps up with chapter seventeen where techniques (and much encouragement) for exploring the Rails source code are shared.

The writing is excellent and the style is very engaging. Every concept is stunning well explained. Much as I liked and enjoyed "Programming Ruby" (the "pickaxe book" to it's friends) by Thomas, Fowler and Hunt, this book takes the state of Ruby writing to a new level.

The progression of the book is very well thought out. The first part introduces us to both Ruby and Rails. You can create basic Rails applications with very little Ruby and that's exactly what this first part walks you through. Then parts two and three teach Ruby skills and idioms that are directly applicable to Rail application creation. Part four takes these new skills and shows them being applied to the second Rails application of the book. I found this to be a very good sequence for progressing through the material.

The examples in the book are excellent and many of them are geared towards Rails-style situations. This not only helps to teach Ruby skills, but also keeps the Rails context firmly front and center during the process.

The index on this book is a magnificent 17 pages. That's not something you see too often.. The art of a good index seems to be somewhat lacking these days, but this book helps to redress the balance.

If Ruby on Rails is of no interest, then this book is most likely not the one you want. Also, if you were looking for something with an exhaustive, reference-style, coverage of Ruby, perhaps you'd be better off considering something like the "Programming Ruby" book.

This is a great book, that's very easy and enjoyable to read. It's a stunningly well written explanation of real-world Ruby skills for Rails development."

You can purchase Ruby For Rails from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page

kale77in asks: "I've become a big fan of Ruby over the past few months, but I'm not at all sure about Ruby On Rails. Automatic code generation sets of alarm bells in my mind; so that, to RoR's promise of 'Web Development that Doesn't Hurt', I automatically add '...until you have to maintain it'. On the other hand, some writers and coders I respect (like the Pragmatic Programming mob) seem to be fans. I've mainly written generators in Python, to produce PHP/SQL/Java from SQL files, but I've always gone back to well-constructed objects, where extension and overloading offers more precise and maintainable customization than auto-generation allows. So is Rails just a nice RAD tool for disposable, cookie-cutter apps (which have a place, of course)? Is high-level generation just a bad OO substitute? And what has your experience of Rails' maintainability been?"

Bart Braem writes "The Ruby community is abuzz about Rails, a web application framework that makes database-backed apps dead simple. What's the fuss? Is it worth the hype? Curt Hibbs shows off Rails at ONLamp, building a simple application that even non-Rubyists can follow."

Amit Upadhyay writes "KDE's award winning integrated development environment KDevelop, has integrated support for Ruby, an excellent and easy to use object oriented scrpting language. If you are looking for a good programming tool for quickly developing a professional one off application, Ruby (with KDE bindings) maybe just the thing for you. There is a quick tutorial and an online book to get you started. You may also want to read a quite informative comparison of Python with Ruby. If you are web developer or write enterprise applications with JAVA etc, take a look at Ruby on Rails(api), they have a nice blog too. KDevelop provides a GUI builder and Debugger for rapid application development(RAD) with Ruby, which is getting better. There is a nice tutorial on using KDE libraries with Ruby. And if you have lots of code in C/C++, extending Ruby to use them is easy.
"

Pan T. Hose writes "The long awaited release of Parrot 0.1.1 "Poicephalus" has been finally announced on perl.perl6.internals newsgroup and perl6-internals mailing list simultaneously by Leopold Toetsch followed by an announcement on use Perl by Will Coleda and now also on Slashdot." (Read on for a list of changes since the last release, as well as a number of useful links.) Pan T. Hose continues "The most important changes since the previous version 0.1.0 (code-named 'Leaping Kakapo' and released in February) are:

• Python support: Parrot runs 4/7 of the pie-thon test suite
• Better OS support: more platforms, compilers, OS functions
• Improved PIR syntax for method calls and <op>= assignment
• Dynamic loading reworked including a "make install" target
• MMD - multi method dispatch for binary vtable methods
• Library improvement and cleanup
• BigInt, Complex, *Array, Slice, Enumerate, None PMC classes
• IA64 and hppa JIT support
• Tons of fixes, improvements, new tests, and documentation updates

The amazing project which no one had any idea would go so far from the original April Fool's Joke by Simon Cozens (also posted on Slashdot on April 1, 2001) to really unite Perl and Python one day (not to mention Tcl, Scheme, Forth and Ruby, to name just a few) is now available for download from CPAN and via CVS. Those who are not up-to-date with Perl 6 mailing lists can read This Week in Perl 6 weekly summaries by Piers Cawley to have some idea on how's the project been going in the last two years. It's important to read Apocalypses, Exegeses and Synopses together with RFCs and Parrot Design Documents for better understanding of the underlying rationale, especially the superiority of register-based Virtual Machines (like Parrot VM) over stack-based one (like JVM) for modern (dynamically-typed) OO languages with multiple inheritance, operator overloading, traits, roles and much, much more. Parrot Docs, FAQ and examples are also very helpful. This is a very important step in the direction of Perl 6 which we are all looking forward to."

anonymous writes "The Free Software community is on a quest for the next generation development environment. Is it .Net, is it Java? Many (including Havoc) are quick to dismiss some of the gems invented by the Free Software community itself. Yes, Ruby is an incredibly consistent and clean language designed specifically to incorporate many of the best features and ideas of predecessors. Absolutely everything in Ruby is an object and practically everything can be redefined or extended on the fly. The effects and resulting power of such flexibility can be quite astounding to those who have adapted to contemporary language limitations. Now, the Ruby environment has been seamlessly integrated into KDE through Korundum, meaning that well-integrated and first-class desktop citizens for Linux can be sketched and developed in an extremely short time. Caveat: No explicit compilation is required and programming seems so easy it feels like cheating."

Andrew Walrond writes "Rubyx the OS is created from source by rubyx the ruby script. Got it? The same small ruby script handles all subsequent package management, customised parallel and distributed user-mode package builds, and can create a live CD. For good measure, Rubyx (the os) sports an all new init and rationalised service management system written in ....can you guess?..."

Java Coward writes "Eric Herman and MySQL's Brian "Krow" Aker have released code to allow the DBMS MySQL to run Java natively inside of the database. The code allows users to write functions inside of the database that can be then used in SELECT/INSERT/UPDATE statements. So when will someone do Ruby?"

Simon P. Chappell writes "Now, I enjoy a good technical book more than the next geek, but it's been quite a while since one left me quite so excited with the possibilities that it presented. Code Generation in Action is beyond interesting, it is a masterful tome on its subject matter, written by one who is obviously an experienced practicioner in his craft." If "code generation" isn't a familiar term to you, this enthusiastic overview on devx.com is a concise introduction to what code generation is about, though it makes no pretense of ambivalence about its importance as a programming tool. Read on for the rest of Chappell's review. Code Generation in Action author Jack Herrington pages 342 (10 page index) publisher Manning rating 9 reviewer Simon P. Chappell ISBN 1930110979 summary A masterful tome.

Overview Code Generation in Action, CGiA to its friends, is presented in two parts. The first part is four chapters, and covers a code generation case-study, the basic principles of code generation, including the different types of code generation strategies together with reasons why you would or would not use each strategy. The book's chosen toolset for building generators is presented next, and then some walk-through examples of building simple generators wraps up the first part.

The second part is a kind of a cross between a cookbook and a list of engineering solutions. There are nine chapters with the breadth of solutions covered being quite impressive, covering the gamut of generation of user interfaces, documentation, unit tests and data access code. Each chapter presents a couple of solutions within its topic area, often for different technologies within that topic. For example, the user interface chapter covers the generation of Java ServerPages, Swing dialog boxes and then Microsoft MFC dialog boxes. No favouritism here!

What's To Like There's a lot to like with this book. The writing is very clear and of good prose. I found the introduction to be very compelling, and I felt completely drawn in by the opening case-study. The four chapters of part one are a concise case for code generation, and would be very useful information to help persuade co-workers and management of the positive risk/benefit ratio with trying code-generation on a live project.

It would be impossible to try enough of any solution from part two in a time-frame short enough to make this review useful, but in the solutions that match my areas of knowledge, I found myself admiring Herrington's straight-forward and pragmatic approach.

What's To Consider There are two aspects of this book that I want to flag. One of these aspects, some will love and others will hate, and that is the choice of generator language for CGiA. The author has chosen to use Ruby as his working language. This is an interesting choice. Ruby is certainly a language that is inspiring a lot of admiration these days (in fact, it's hard to get Dave Thomas to stop talking about it :-), but with the majority of the code-generation examples being for Java-related technologies, I wonder why Java was not selected instead.

I also found myself wondering about the lack of discussion of how to integrate these Ruby tools into a typical Java build process. Many developers I know use ant to bring automation and consistency to their builds, yet the book doesn't mention this. (JRuby anyone?) Certainly something to consider for the second edition or future code-generation authors.

Summary

This is a masterful tome that inspires and delights, although the two issues raised above did cost it a perfect score of ten.

Table Of Contents

1. Code generation fundamentals
2. 1. Overview
   2. Code generation basics
   3. Code generation tools
   4. Building simple generators
3. Code generation solutions
4. 1. Generating user interfaces
   2. Generating documentation
   3. Generating unit tests
   4. Embedding SQL with generators
   5. Handling data
   6. Creating database access generators
   7. Generating web services layers
   8. Generating business logic
   9. More generator ideas

You can purchase Code Generation in Action from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

waieitch writes "A long-waited new version of the scripting language, Ruby 1.8.0 has just been released. You can download from here, and the changelog is available. With many new libraries, say dRuby, ERB, REXML, this version is doubled by 1.6.8 in size."

waieitch writes "A long-waited new version of the scripting language, Ruby 1.8.0 has just been released. You can download from here, and the changelog is available. With many new libraries, say dRuby, ERB, REXML, this version is doubled by 1.6.8 in size."

tcopeland writes "RubyForge is a new hosting area for open source Ruby projects. It's powered by the popular GForge fork of SourceForge development. There's even a couple of code snippets up there already."

Simon P. Chappell writes "The Eclipse IDE has thundered into the collective consciousness of Java developers since its release by IBM as Open Source Software. Up until this time, the majority of available documentation at the Eclipse website has been for plug-in developers, with scant attention given to the rest of us that actually want to use the tool for anything else. This book restores the balance and brings much needed help to those interested in this IDE." Read on for the rest of Simon's review, about which he says "Full Disclosure: I received a free, review copy of this book, so feel free to assume that I've been bought off and have traded my technical integrity to put about an inch of dead tree on my shelf." Eclipse in Action author Gallardo, Burnette and McGovern pages 383 (15 page index) publisher Manning rating 8 reviewer Simon P. Chappell ISBN 1930110960 summary A good book that lives up to its name.

Overview With a book like this it's difficult to know where to pitch the level. Do you aim for the lowest common denominator or do you assume some experience on the part of your reader? This book seems to have pitched itself well, not pandering to the absolute Java newbie, not afraid to get down into the code and yet gentle enough that newer Java developers can follow easily. The heavyweight chapter on writing plug-ins is at the back where it shouldn't frighten those of a sensitive nature.

The book is divided into two sections. The first and largest section concerns actual use of Eclipse during Java application development. The second section is for those who wish to write plug-ins for Eclipse.

The book takes a very 'Test Driven Development' approach to Java development and this shows in the manner that Eclipse is presented and taught. Emphasis is given to the tools that come with Eclipse, especially Ant, Junit and the CVS client. For those already skilled in these tools, this might seem like filler, but remember that there are still pitifully few Java developers using even these simple and free tools. My hat is off to the authors for their TDD evangelism, skillfully disguised as Eclipse usage instruction.

What's To Like I liked the progression followed in the book, first teaching the basic operation of Eclipse and then moving on to the tools that come with the base install. What's To Consider Some may consider that the material on Ant, Junit and CVS is filler. The 'Test Driven Development' theme may be a little too much evangelism for some.

I use Eclipse on a Mac OS X box and I felt that there was very little discussion concerning the cross-platform attributes of the tool. All of the screenshots were from a Microsoft Windows build of the software; a Linux or OS X screenshot would have been helpful.

One more niggle and then I'm done. There is no information on using Eclipse with other programming languages (a couple of paragraphs in the introduction chapter doesn't really count). I've recently started tinkering with Ruby and have used a Ruby plug-in to allow me to work within Eclipse as I learn the language. This is a wonderful testament to the power and extensibility of Eclipse.

Summary This is a good book. You know it's a good book when you already use the tool (both pure Eclipse and IBM's WSAD) regularly and you find yourself learning things that you had not previously been aware of. If you are working with Java and want a good free IDE that's going to grow with you, then Eclipse is a tool you should try -- and consider this book the User's Guide that would have been in the box if Eclipse came shrink-wrapped.

Table Of Contents

1. Using Eclipse
2. 1. Overview
   2. Getting started with the Eclipse Workbench
   3. The Java development cycle: test, code, repeat
   4. Working with source code in eclipse
   5. Building with Ant
   6. Source control with CVS
   7. Web development tools
3. Extending Eclipse
4. 1. Introduction to Eclipse plug-ins
   2. Working with plug-ins in Eclipse

You can purchase Eclipse in Action from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

flounder_p queries: "I have recently started playing with the Ruby programming language and think it's really great. I was just wondering why you guys think Ruby has not caught on more in the open source community than it has? How many of you guys are using it? Will it ever catch on or will it always be looked at as yet another scripting language? Don't get me wrong scripting languages are great (and I live by Perl) but I still hope to see Ruby catch on more. I would like to hear opinions on things on why Ruby is good or bad not on why OOP is good or bad. We have already had that discussion here." On a side note, a little birdy tells me that BlackAdder has plans for Ruby support in its next beta.

zby queries: "I've been using the 'Perl Cookbook' extensively for 2 years already and have found the book to be really helpful. Recently I've been learning about Ruby and I really miss that kind of resource. That gave me the idea to build that kind of knowlege base as an free project. I believe it just fits ideally, and could be run on a Slash or Scoop based system without any modifications from the beginning." It sounds like a grand idea, however are there any other such resources on the web?

swagr writes "Some new and interesting information on the Ruby website.
1: O'Reilly is apparently publishing a translation of "Ruby Pocket Reference" (although this news doesn't seem to be on O'Reilly's site
2: There is a Ruby Conference happening in October.
3: They need some help with a Ruby mascot (1337 gimpists: go nuts)."

Kailden asks: "I've run across several references to Ruby, a scripting language that claims to be a hybrid of Perl and Python. Supposedly, this language has taken Japan by storm. I'm looking for Slashdot's verdict before jumping in. Has anyone outside the Ruby site used this language? What advantages/disadvantages have you found?"