Ruby Weekly News 23rd - 29th May 2005

http://www.rubyweeklynews.org/20050529.html

   Ruby Weekly News 23rd - 29th May 2005
   -------------------------------------

   Ruby Weekly News is a summary of the week's activity on the ruby-talk
   mailing list / the comp.lang.ruby newsgroup, brought to you by
   Tim Sutherland.

Articles and Announcements
--------------------------

     * Rails Day Registration is Now Open!
       -----------------------------------

       Lucas Carlson announced "If you want your chance at thousands of
       dollars of prizes for one day's work with Rails, please register
       soon".

       Rails Day is a competition that gives you 24 hours to write the best
       web application you can, using Ruby on Rails. You can do it
       individually or as part of a two or three person group.

       It's all on June 4th (hurry!)

       Judges include Rails creator David Heinemeier Hansson and the
       co-author of `The Pragmatic Programmer' and `Programming Ruby', Dave
       Thomas.

     * 2005 ICFP Programming Contest
       -----------------------------

       Robby Findler announced that the 2005 Programming Contest of the
       International Conference on Functional Programming was just four weeks
       away.

       "This year's competition rewards programmers who can plan ahead. As
       before, we'll announce a problem and give you three days to solve it.
       Two weeks later, we'll announce a change to the problem specification
       and give you one day to adapt your program to the new spec. And you
       guessed it: the second half will be worth considerably more than the
       first."

     * Rail Beta Book now available
       ----------------------------

       Dave Thomas released the beta version of the Rails book he is
       co-writing; `Agile Web Development with Rails'.

       "This is basically a pre-copyedit, pre-layout version of the book,
       available as a PDF. Buy it now (either as a straight PDF or as a
       combo-pack with the paper book) and we'll ship you the Beta PDF now,
       then ship you the final PDF (along with the paper book if you ordered
       it) when the book is finished (around the first of August)."

Quote of the Week
-----------------

   Matz explaining POLS (Principle of Least Surprise).

   This acronym was often in the past used by Rubyists to cheerfully declare
   that language design decisions were resolved simply by determining which
   option was the `least surprising'.

   POLS has since become notorious for generating long, futile threads where
   someone with a background in one language argues that a feature should
   behave in a certain way (since that's the way the other language does it,
   that is the `least surprising' way to them). Of course, someone with a
   different background would then say `actually, I think the following would
   be the least surprising', and the thread spirals onwards.

   The quote itself:

    | Since someone will surprise for any arbitrary choice, it is impossible
    | to satisfy "least surprise" in his sense. The truth is two folds: a)
    | when there are two or more choices in the language design decision, I
    | take the one that makes _me_ surprise least. b) as a result, you will
    | have less surprise in Ruby than other languages, once you have
    | accustomed to it.
    |
    | But I'm tired of explaining POLS again and again. I haven't even used it
    | first. I hope no one will use the term "POLS" any more to sell Ruby.
    | It's free after all.

   Matz' comment was inspired by the thread
   'A different perspective on Ruby' which comments on a rant by Eric Will.
   (Warning: Rant contains a lot of swearing.)

   The rant listed a number of things that Eric didn't find `least
   surprising' - "So much for POLS ... So much for POLS ... So much for
   POLS."

   How about Language Agreeing with Matz' Expectations? Then people can
   complain that that Ruby isn't LAME :-)

Link of the Week
----------------

   Link of the Week: "Anarchaia" by Christian Neukirchen.

   A blog, sort of. (But mostly not.) It's an intermingling cascadra of
   links, quotes, images and thoughts all racing down the page (and down,
   down, down - it's very long, you see.)

   The #ruby-lang IRC channel is regularly quoted, as are other
   interesting-to-programmer places. It's freaking crazy awesome, man.

   Rubyists may know Christian from his Ruby projects,
     - RubyPants smart-quotes library
     - a Real Life Markup Language (RLML) parsing library
     - Nukumi static blogging system (and now Nukumi2)
     - slider, a "cool application launch bar"


   (Please send in your suggestions for the next Link of the Week.)

Threads
-------

   Interesting threads included:

  Useless hack of the saturday morning
  ------------------------------------

   gabriele renzi found a "nifty" piece of Perl code. He translated it into
   Ruby, the magic part of which was implementing the gather and take
   functions of Perl 6.

   gather-take is used to construct an array in the following way; gather
   takes a block and returns an array. Within the block, every time take is
   called it adds its argument to the array.

   Example:

 p gather {
   take 1
   take 2
   take 3
 }
 # -> [1, 2, 3]

   The above is equivalent to

 arr = []
 arr << 1
 arr << 2
 arr << 3
 p arr
 # -> [1, 2, 3]

   The difference is that the first example doesn't need to explicitly
   declare the array.

   gabriele's implementation:

 class Gatherer
   attr :gathered
   def take(arg)
     @gathered||=[]
     @gathered<< arg
   end
 end

 def gather &blk
   c=Gatherer.new
   c.instance_eval &blk
   c.gathered
 end

   Pay close attention to how he calls instance_eval on a block. That causes
   the block to be evaluated such that self inside the block is c, rather
   than the self from the lexical scope of the block definition.

   The result is that when the code inside the block calls take, it is c.take
   that is called.

   Christian Neukirchen (familiar name) thought it looked useful, but was
   concerned about unintended effects of the instance_eval. (It all goes
   horribly wrong, for example, if your block refers to instance variables or
   methods.)

   He suggested using Dynamic Variables instead.

   Chris also noted that gather-take is available in the GOO programming
   language, where it is known by packing-pack.

  preventing Object#send from dispatching to a global method?
  -----------------------------------------------------------

   Francis Hwang outlined the following snippet of code -

 def something; end

 class SomeClass
   def method_missing( sym, *args ) .... do magic; end
 end

   and asked if it is possible to make SomeClass.new.something call
   SomeClass#method_missing instead of the `global method' something. (Such
   methods are added to Object, and are therefore available to all objects by
   default.)

   Bertram Scharpf gave:

 class SomeClass
   undef :something
 end

   Jim Weirich suggested Francis look at the code in Builder::BlankSlate
   (part of the Builder for Markup library). It provides a class whose only
   methods are __send__ and __id__. It also uses undef.

   itsme213 said that this could all have been avoided if only `global
   methods' in Ruby were singletons of the main object, rather than additions
   to the Object class.

  a deepcopy for "array = [1,2,3]*5"?
  -----------------------------------

   Boris asked "What way would you create an array that contains 5 copies of
   an array, without the copies interfering with each other?"

   He had tried

 array = [[1,2,3]]*5
 # ->  [[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3]]

   However the result is 5 references to the same array:

 array[1][1] = "a"
 # -> [[1,"a",3],[1,"a",3],[1,"a",3],[1,"a",3],[1,"a",3]]

   Brian Schrer said he should simply use

 array = Array.new(5) { [1, 2, 3] }

   That creates an Array of 5 values. They are initialised by calling the
   block 5 times, which results in 5 different array objects.

  Making a scripting tutorial
  ---------------------------

   Vincent Foley would like to present Ruby to the Linux Users Group he
   attends, in Quebec. The audience is mostly system administrators rather
   than programmers, so it would be best to demonstrate Ruby's utility as a
   `scripting language'.

   What sort of material could he cover in an introduction? James Britt
   thought that Vincent shouldn't try to go over too much. Instead, "show
   enough about scripting in general, very high-level, and some Ruby in
   particular, so as to generate interest in further exploration."

   Henrik Horneber gave a link to whytheluckystiff's article
   'Wearing Ruby Slippers To Work' which shows Ruby code performing the
   same sort of tasks that sysadmins often use find, grep and friends for.

   Others posted links to tutorials and to presentations that have previously
   been used.

  UDPSocket#recvfrom is slow
  --------------------------

   Niklas Frykholm found that the UDPSocket#recvfrom method was "extremely
   slow" (two seconds per call), whereas UDPSocket#recv was super fast.

   He guessed that the difference was that recvfrom attempts to convert an IP
   address to a network name. "Apparently, on a (badly configured???) Windows
   network, this can be a really slow operation."

   Kent Sibilev said that you can write

 Socket.do_not_reverse_lookup = true

   to disable the conversion. Niklas confirmed that this solved his problem.

New Releases

     * cursor-0.6

       Eric Mahurin enhanced cursor, a library that provides powerful
       external iterator features based on the `cursor' editor metaphor.

       "Compared to most other general external iterators, Cursor offers two
       interesting features - ability to insert/delete and the ability to
       save/restore a position."

       Some interfaces were simplified and more methods added.

       The thread discussed the general approach, with Eric noting that he's
       working on a library called Grammar, "used to match what's next in
       Cursor".

     * Finite State Ma-thing 0.6

       Gavin Kistner announced the `Finite State Ma-thing', a library that
       assists in the implementation of finite state machines.

     * HighLine 0.6.1

       James Edward Gray II released HighLine 0.6.1. This resolves an
       installation issue for Windows users.

       HighLine is a library that makes it easy to write console
       applications. It provides high level services for such things as
       asking questions of the user and receiving answers.

     * ZenHacks 1.0.0

       Ryan Davis announced ZenHacks 1.0.0.

       "A cornucopia of hackery. Toys, Tricks and Tools that have spawned out
       of my other projects (RubyInline, ParseTree, Ruby2C, etc) but don't
       exactly fit there. This includes ZenDebugger, ZenProfiler,
       ZenOptimizer, ruby2ruby, and more."

     * Packgen 0.2

       Ghislain Mary released Packgen 0.2, a network packet generator. It can
       be used to analyse the performance of your network.

       This release includes the ability to generate graphs containing
       information such as "bandwidth, the packet size, the packet count, the
       packet loss, the interarrival and the jitter of your packet flows."