Rails 3: browse the source-code at railties/lib/rails/info.rb

Or see:

Rails 2: browse the source-code at railties/builtin/rails_info/rails/info.rb

Or see:

Till the next time…

Obsolation note:

Thanks to Dave Coleman’s comment I found out that glpk is available through homebrew now! So you just need these 2 steps to get glpk now:

1. homebrew
2. brew install glpk

If you still want to read on, the old way is still here…

So you want copy-paste instructions to install GLPK on your Macbook? Here are the steps:

1. Download the latest version of GLPK from http://www.gnu.org/software/glpk/#downloading
2. Optional: Follow the instructions to verify the download (you might need to get GNU Privacy Guard or gpg for this. You can get it at http://gnupg.org)
3. Say it’s downloaded to your “Downloads” directory, go there and execute the following commands (using the terminal)

   cd ~/Downloads
   tar -xzf glpk-4.43.tar.gz
   ./configure --prefix=/usr/local # see note [1]
   make
   sudo make install
       

4. At this point, you should have GLPK installed. Verify it:

   which glpsol
   /usr/local/bin/glpsol
       

5. … and try help:

   glpsol --help
       

Now that you are all set-up, read up this excellent introduction using GLPK: http://www.ibm.com/developerworks/linux/library/l-glpk1

Notes:
[1]: HiveLogic article on why using /usr/local is better
[2] If you want MySQL support (or something “extra”) check out the INSTALL file in the package

Read more: School-boy example of how and why it works and about Ancient Egyptian Multiplication on wikipedia

So here’s my simple implementation: (or as a gist on github)

module RussianPeasantMultiplication
  def russian_peasant_multiply(b)
    numbers_to_add = []
    a, b = [self, b].sort #So we have the smaller number as the first

    negative_operands = [a, b].select { |n| n < 0 }
    result_should_be_negative = negative_operands.size.odd? # or negative_operands.size == 1

    # Now get the absoultes
    a, b = [a, b].map { |n| n.abs }

    while( a > 1 )
      a = a >> 1 # halv it
      b = b < < 1 # double it
      if a.odd? # or (a % 2 == 0 )
        numbers_to_add << b
      else
      end
    end
    result = numbers_to_add.inject(0) { |sum, n| sum += n }
    result = result * -1 if result_should_be_negative
    result
  end
end

class Integer
  include RussianPeasantMultiplication
end

# Tests
require "test/unit"

class TestInteger < Test::Unit::TestCase
  def test_russian_peasant_multiply
    assert_equal(22 * 70, 22.russian_peasant_multiply(70))
  end

  def test_russian_peasant_multiply_for_negative_numbers
    assert_equal(-22 * 70, -22.russian_peasant_multiply(70))
  end

  def test_russian_peasant_multiply_for_negative_arguments
    assert_equal(22 * -70, 22.russian_peasant_multiply(-70))
  end

  def test_russian_peasant_multiply_for_negative_numbers_and_arguments
    assert_equal(-22 * -70, -22.russian_peasant_multiply(-70))
  end

  def test_russian_peasant_multiply_for_zero
    assert_equal(0 * -70, 0.russian_peasant_multiply(-70))
  end

  def test_russian_peasant_multiply_for_zero_arguments
    assert_equal(-22 * 0, -22.russian_peasant_multiply(0))
  end

  def test_russian_peasant_multiply_for_zero_numbers_and_arguments
    assert_equal(0 * 0, 0.russian_peasant_multiply(0))
  end
end

Situation:

• I have two tables (Revisions has_many Inputs)
• I can load Revisions and then for each I can find Inputs, but quickly found out that for my situation, it leads to a lot of queries. So I want to load the required fields from both tables together

:joins is the only way to do this, using :includes does NOT respect the select clause. Here is the gist I created:

Admittedly, this is hacky, too hacky for my comfort. Comment/suggest a better/cleaner solution?

Note: Found out that there is a gem to do this: ar-select-with-include

This blog is about twitter hastags. To learn more about twitter hashtags, go here.

So #songsincode has been ruling the twitter trends for a day now). Didn’t follow it? No worries – here’s a recent blog with some good (early) ones.

Basically, it was the most fun I have had reading hashtags. Today, after lunch I took a plunge too

Original tweet here:

(you.breath + you.move).each { i.missing(you) }

Original tweet here:

while ( time(you.reverse) < = 1.minute )
  i = you.steps_behind(2)
end

Oh don’t tell me I was so bad you could not even guess the songs (Every Breath You Take and Two Steps Behind.

Basically it is the practice of checking if a particular log message will indeed be outputted to the log (based on the severity level) before calling the log statement. This is a performance improvement.

// Java example
if( logger.isLoggable(Level.INFO) ) {
  logger.info( "this is a " + "info" + "message" );
}

So I heard from one of my colleagues that Ruby’s logging performance can also be improved the same way, by putting the message in a block (instead of just passing it as an string arg to the method):

  @logger.debug { "this is a " + "debug" + "message" }

See various ways to log a message at the ruby-docs (search for “How to log a message” in that page).
I looked into the source-code and, just like in Java, the first thing that is done is to check the severity and return (true) if the severity is higher than the message’s. So like in Java, it should not have any effect (except creating the strings etc.).

Just to test it out, I wrote a benchmark test:

require 'benchmark'
require 'logger'

class LoggerBenchmark
  def initialize
    @logger = Logger.new("/dev/null")
  end

  def benchmark
    n = 10000
    # I use bmbm method and not bm here
    # so the effects of initializing etc. are abstracted away
    Benchmark.bmbm do |x|
      x.report("with block") do
        n.times do |i|
          # trying to do *some* arithmetic here
          # so there is *some* work for string-creation
          @logger.warn { "logging with block - #{rand * 1000 % i}" }
        end
      end

      x.report("with string") do
        n.times do |i|
          @logger.warn "logging with string - #{rand * 1000 % i}"
        end
      end

      x.report("with severity check") do
        n.times do |i|
          if @logger.warn?
            @logger.warn("logging with severity check - #{rand * 1000 % i}")
          end
        end
      end

    end
  end
end

LoggerBenchmark.new.benchmark

Here’s what I noticed:

• with n (the number of logging calls) set to < = 10,000, there was really no difference between the three ways:

  $ time ruby logger_benchmark.rb
  Rehearsal —————————————————————
  with block            1.340000   0.160000   1.500000 (  1.500111)
  with string           0.740000   0.110000   0.850000 (  0.845971)
  with severity check   0.650000   0.080000   0.730000 (  0.736908)
  —————————————————— total: 3.080000sec
  
                                    user     system      total        real
  with block            0.670000   0.100000   0.770000 (  0.765206)
  with string           0.640000   0.080000   0.720000 (  0.715421)
  with severity check   0.660000   0.080000   0.740000 (  0.733024)
  ruby logger_benchmark.rb  4.72s user 0.62s system 99% cpu 5.351 total
  

• with n set to 100,000: It looked like the simplest way to log (with a string-arg) still performs the best:

  $ time ruby logger_benchmark.rb
  Rehearsal ---------------------------------------------------------------
  with block            7.630000   1.030000   8.660000 (  8.669890)
  with string           6.410000   0.840000   7.250000 (  7.270509)
  with severity check   6.570000   0.890000   7.460000 (  7.472230)
  ----------------------------------------------------- total: 23.370000sec
  
                                    user     system      total        real
  with block            6.760000   0.930000   7.690000 (  7.697947)
  with string           6.320000   0.870000   7.190000 (  7.190802)
  with severity check   6.460000   0.930000   7.390000 (  7.394368)
  ruby logger_benchmark.rb  40.20s user 5.50s system 99% cpu 45.755 total
      

Final takeaway: it really does not make that big a difference and keeping it simple (with a string-arg) should work. If you are worried about performance, this probably is not a trick that will give you a big bang for the buck.

Object#clone
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. Copies the frozen and tainted state of obj.

Object#dup
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. dup copies the tainted state of obj. See also the discussion under Object#clone. In general, clone and dup may have different semantics in descendant classes. While clone is used to duplicate an object, including its internal state, dup typically uses the class of the descendant object to create the new instance.

This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy method of the class.

So in essence, both produce shallow-copies of the object. clone copies the frozen and tainted state while dup copies only the tainted state. Even after reading that documentation twice, it’s still murky in my head (probably coz I have not had a chance to write code to notice the frozen or tainted state specifically.)

Here’s a gem from ruby-talk that Google brought up: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/6328. So Matz says:

`clone’ copies everything; internal state, singleton methods, etc.
`dup’ copies object contents only (plus taintness status).

And so I wrote a bit of code to see it myself (and thus remember it). Here’s a very simple Person class:

class Person
  attr_accessor :name
end

Now we instantiate a Person object (p) and add then an singleton method on the new object (p) to say hi:

p = Person.new
p.name = "The Man"

# now add a singleton method on p:
def p.say_hi
  "'sup"
end

See that it’s all working:

irb(main):014:0> puts p.inspect
#<person :0xb7e83340 @name="The Man">
=> nil
irb(main):015:0> puts p.say_hi
'sup
=> nil

Now create a clone and a dup of it:

the_clone = p.clone
the_dup = p.dup

Both the clone and the dup have the same instance variables (which are shallow-copies BTW), but only the clone has the singleton method (say_hi) in it:

irb(main):018:0> the_clone.name
=> "The Man"
irb(main):019:0> the_dup.name
=> "The Man"
irb(main):020:0> the_clone.say_hi
=> "'sup"
irb(main):021:0> the_dup.say_hi
NoMethodError: undefined method `say_hi' for
(Person :0xb7e83340 @name="The Man")
        from (irb):21
        from :0
irb(main):022:0>

So that makes me feel that clone has to do more work than dup does. Hence dup might be more beneficial for performance compared to clone (unless you really need to use clone). Comments are welcome! ]]> http://www.arnab-deka.com/posts/2009/07/ruby-dup-vs-clone/feed/ 2 http://www.arnab-deka.com/posts/2008/07/ruby-private-class-method/ http://www.arnab-deka.com/posts/2008/07/ruby-private-class-method/#comments Sat, 19 Jul 2008 01:37:00 +0000 Arnab http://www.arnab-deka.com/posts/2008/07/ruby-private-class-method/

The following is just so I can remember it… You need not read all this.

In Java, if you need a class whose constructor is private – so you can’t instantiate it from anywhere else, you’d do:

public class AClass {
  private int a;
  private AClass(int a){
    super();
    this.a = a;
  }

In Ruby, it’s a bit different. The why will come later (dynamic language), but just hiding the initialize method is not enough. You can still create an object coz you are actually calling the new method:

irb(main):001:0> class AClass
irb(main):002:1>   attr_reader :a
irb(main):003:1>   private
irb(main):004:1>   def initialize(a)
irb(main):005:2>     @a = a
irb(main):006:2>     end
irb(main):007:1>   def some_other_method
irb(main):008:2>     "ha"
irb(main):009:2>     end
irb(main):010:1>   end
=> nil
irb(main):011:0> obj = AClass.new(100)
=> #<aclass :0xb75768c4 @a=100>
irb(main):012:0> obj.a
=> 100
irb(main):013:0> obj.some_other_method
NoMethodError: private method `some_other_method' called for #</aclass><aclass :0xb75768c4 @a=100>
        from (irb):13
        from :0
irb(main):014:0>

You’d have to hide the new method:

class AClass
  attr_reader :a
  def initialize(a)
    @a = a
  end
  def self.test
    "test"
  end
  private_class_method :test
end

puts AClass.test

That shows:

test.rb:12: private method `test' called for AClass:Class (NoMethodError)