The application let user book a part number, by filling some information. For better user experience, I plan to capture the username at the other end that make the booking, instead of creating another layer of login feature and require the user to login again. There is no complex authentication needed, just capture the username and store it together with other information.

ENV['user'] will give you the username that has the rails application running, which is not what we want.
ENV['remote_user'] return nothing at all.
I read through quite a few discussions on the net, it seems like apache didn’t actually pass the remote_user value to mongrel, hence rails application couldn’t call out remote_user. To fix that, we will need to modify on the apache configuration file, httpd.conf, and .htaccess. Admittedly, I really know close to nothing about the setup of these files, and have a hard time following the suggested steps, as to where to add the suggested line of codes, which file to modify, etc, etc.

So I figure, if we forgo apache in the setup, will it be easier to fetch the remote_user value directly from mongrel? or from thin if it is the web server being used.

But still, I just couldn’t get it working.
Is there any gem or plugin need to be installed before this remote_user tingy can be pass to rails application?

As I am looking for moving my little rails application out of instantrails to a proper production environment, decided to give thin a spin, too bad Passenger isn’t supporting Windows platform, heard a lot of good thing about it too.

Installing thin server on Windows isn’t quite straightforward though. Thin actually consist of mongrel parser, EventMachine, and rack, but the latest EventMachine gem is not win32 binary release, that pose a lot of problem for the installation.

There are a few workarounds suggested on the net,
from Winston

But this didn’t quite workout for me, some suggested to install MinGW and MSYS, then the normal path of gem install thin should just work. Tried that, but fail as well.

Then found out that EventMachine has a binary release at 0.12.6, and with that it works right away for me , here are the steps that did it for me,

Only after a full circle of searching around the net, that I found out these steps are actually mentioned in the comments by Marty McGee in winston’s original post. Duh.

This one from codegearguru. Instead of creating graphic, or cutting out paper to represent data in the sorting process, just use the poker cards! That seems obvious now, but I didn’t think about it when I try to illustrate sorting to myself initially. Ha. Think there is a series of video created for different type of sorting algorithm as well, so definitely a great tool to understand sorting algorithm. Bonus near the end of the video, another technique called shaker sort or cocktail sort is also explained, which is basically a bidirectional bubble sort which should speed up the sorting speed.

Another one from Miles Hauskaz, just plain simple and succinct explanation and a video nicely done as well.

Sorting Algorithms – Bubble Sort from Miles Hauskaz on Vimeo.

So, this is my implementation of bubble sort, admittedly not the best that you can find, but that will do for me now, until I have time to come back and do some refactoring.

arr = %w{g a c b j e e}
i = arr.length - 1
count = 0
n = arr.length - 1
def swap(m,n) 
  arr = []
  if m > n
    arr << n
	arr << m
  else
    arr << m
	arr << n
  end
end
 
while n > 0
  while count < i
    puts "comparing #{arr[count]} to #{arr[count+1]}"
    a = swap(arr[count],arr[count+1])
    arr[count..count+1] = a
    count += 1
  end
  n -= 1
  i -= 1
  count = 0
end
p arr

irb(main):001:0> name = %w{guido knuth adrian dhh pg}
=> ["guido", "knuth", "adrian", "dhh", "pg"]
irb(main):002:0> name.each {|n| n.upcase}
=> ["guido", "knuth", "adrian", "dhh", "pg"]
irb(main):003:0> name.map {|n| n.upcase}
=> ["GUIDO", "KNUTH", "ADRIAN", "DHH", "PG"]

map and each are suppose to do almost the same thing, but why each didn’t return the correct result in uppercase like what map did?

The different is each yield each element in the collection to the code block, in this case perform the upcase method, but return the receiver, which is the original array, hence an array of lower case names.

Whereas, map return a new array, consists of elements already went through the code block, hence an array of upper case names.

irb(main):007:0> name.each {|n| p n.upcase}
"GUIDO"
"KNUTH"
"ADRIAN"
"DHH"
"PG"
=> ["guido", "knuth", "adrian", "dhh", "pg"]
irb(main):006:0> name.map {|n| p n.upcase}
"GUIDO"
"KNUTH"
"ADRIAN"
"DHH"
"PG"
=> [nil, nil, nil, nil, nil]

So here you can see with p, both map and each output the uppercase names, but look more carefully, the return value of each, as expected, is the original array. map however, return an array of nils!

Why is that?

• I do away with the temporary variable for holding on the smallest number result from each round of the comparison, instead elements are now passed over directly to the sorted array.
• Those elements that get passed to the sorted array, will be deleted from the original array, but one items at one round of comparison, which mean if there are duplicated elements, only one of the instance will be removed.

 hackers.delete_at(hackers.index(sorted[count]))

It look a lot more wordy than a shorter

hackers.delete(sorted[count])

but this is deleting ONLY the first element that match the value, compare to the shorter version where it will remove all elements. So it preserve the other element for next round of comparison, and eventually make it to the sorted array.
Complete code as below,

hackers = %w{ gosling matz dhh adrian guido matz knuth dhh adrian guido }
i = hackers.length
count = 0
sorted = []
 
while count < i
  sorted[count] = hackers.inject{ |a,b| a < b ? a : b }
  p sorted[count]
  hackers.delete_at(hackers.index(sorted[count]))
  count += 1
end
p sorted

And the result….

["adrian", "adrian", "dhh", "dhh", "gosling", "guido", "guido", "knuth", "matz", "matz"]

]]> http://www.kahfei.com/?feed=rss2&p=123 0 http://www.kahfei.com/?p=112 http://www.kahfei.com/?p=112#comments Sat, 17 Jul 2010 06:32:32 +0000 kahfei http://www.kahfei.com/?p=112 Finally have the time to come back to the sorting exercise, here is a slightly better version of sort.
It still doesn’t take care of duplicate elements, but compare to the first sorting version, this one is shorter, as the whole finding smallest element left in the array is now done by inject and a ternary operator, a whole 7 lines of code cut to just 1. And now it no longer sort animals, it sort a list of hackers

hackers = %w{matz ddh adrian guido gosling knuth linus}
i = hackers.length 
sorted = []
while i > 0
  small = hackers.inject{ |a,b| a < b ? a : b}
  sorted.push small 
  hackers.delete small
  i -= 1
end
p sorted

And the result of the sort is

["adrian", "ddh", "gosling", "guido", "knuth", "linus", "matz"]

So the next iteration will be to take care of duplicated elements…stay tuned.

]]> http://www.kahfei.com/?feed=rss2&p=112 0 http://www.kahfei.com/?p=108 http://www.kahfei.com/?p=108#comments Wed, 14 Jul 2010 05:27:17 +0000 kahfei http://www.kahfei.com/?p=108 Apparently you can have optional parameter listed in the middle for your method in Ruby version 1.9

C:\>pik switch 191
 
C:\>irb
irb(main):001:0> def talk(a,*b,c)
irb(main):002:1>   p a,b,c
irb(main):003:1> end
=> nil
irb(main):004:0> talk 'a','b','c'
"a"
["b"]
"c"
=> ["a", ["b"], "c"]

but not Ruby version 1.8.7

C:\>pik switch 187
C:\>irb
irb(main):001:0> def talk(a,*b,c)
irb(main):002:1>   p a,b,c
irb(main):003:1> end
SyntaxError: compile error
(irb):1: syntax error, unexpected tIDENTIFIER, expecting tAMPER or '&'
def talk(a,*b,c)
               ^
        from (irb):1
irb(main):004:0> quit

]]> http://www.kahfei.com/?feed=rss2&p=108 0 http://www.kahfei.com/?p=102 http://www.kahfei.com/?p=102#comments Tue, 13 Jul 2010 21:38:49 +0000 kahfei http://www.kahfei.com/?p=102 A beautiful visualization of sorting algorithm…


via Hacker News

]]> http://www.kahfei.com/?feed=rss2&p=102 0 http://www.kahfei.com/?p=95 http://www.kahfei.com/?p=95#comments Sat, 10 Jul 2010 00:12:16 +0000 kahfei http://www.kahfei.com/?p=95 Another way for factorial, extending the integer class, so the function will feel more natural, instead of fact 6 for example, you just call it by 6.fact.
Also, added a function to sum up the factorial value, counting down. Example, for 6!, it will be 6! + 5! + 4! + 3! + 2! + 1!
Here go,

class Integer
  def fact
    if self == 0
      return 1
    else
      n = self * (self - 1).fact
    end
  end
  def sum_fact
    (1..self).inject{|a,b| a + self.fact}
  end
end
puts 4.fact
puts 4.sum_fact

]]> http://www.kahfei.com/?feed=rss2&p=95 0 http://www.kahfei.com/?p=89 http://www.kahfei.com/?p=89#comments Fri, 09 Jul 2010 10:51:18 +0000 kahfei http://www.kahfei.com/?p=89 Hours ago I got a programming test question about factorial, which I didn’t do really well, only completed with the help of the interviewer. Damn.
The worst thing is that I have done this question before, and I know in the head I can use recursion for it, but I totally go blank on how to do it with recursion. Here go my chance…sigh…

Now, here is how factorial can be done.
With Recursion.

def fact n
  if n == 0
    1
  else
    n = n * fact(n-1)
  end
end

That simple.

Factorial without recursion, using inject instead

def fact n
  if n == 0
    1
  else
    (1..n).inject { |a,b| a*b } 
  end
end

Isn’t that difficult, huh? What was I thinking?!

]]> http://www.kahfei.com/?feed=rss2&p=89 0