PROGRAMMING INTERVIEWS

Sometimes, we need to change header info for S3 objects. One solution is to download file locally and upload it again with new header information.

Using Amazon API COPY functionality, it is possible to change headers on an S3 object without downloading the entire object. We need to set x-amz-metadata-directive as REPLACE to copy a S3 key to the same location.

But if we do this using right_aws ruby gem, ACL information is not preserved. For preserving ACL information as well, we need to preserve ACL permission before changing headers and then apply ACL again after changing headers.

#!/usr/bin/env ruby

require 'rubygems'
require 'right_aws'

@s3 = RightAws::S3Interface.new('AWS_ACESS_KEY', 'AWS_SECRET_KEY', :logger => STDOUT)

#In this example, I'm changing the mime-type to image/png.
#You can change whatever header you want.
update_s3_object_headers(bucket, key, {'Content-Type' => 'image/png'})

def update_s3_object_headers(bucket, key, headers)
      #Saving current ACL
      acl_xml = @s3.get_acl(bucket, key)[:object]
      # Performing a copy with directive REPLACE
      @s3.copy(bucket, key, bucket, key, :replace, headers)
      #Restore ACL
      @s3.put_acl(bucket, key, acl_xml)
end

Question: You are given 2 number streams. You need to find whether they will create the same BST or not.

Example:
Array1:10 5 20 15 30
Array2:10 20 15 30 5
Result: True

Array1:10 5 20 15 30
Array2:10 15 30 20 5
Result: False (see corresponding trees below)

Answer:

Method of building a BST from an incoming stream is like below:

1. Make first element as root.
2. If current element is smaller then root -> insert in left subtree.
3. If current element is greater then root -> insert in right subtree.
4. If current element is equal to root -> skip (or as pre-decided)
5. While inserting in left and right subtree, follow above steps recursively.

So in above question, we have to check top-down if all the subtrees are identical or not. For that, we should follow below steps:

1. Check if stream is finished if yes -> return false
2. Check if both the stream has same number of elements, if not -> return false
3. Check if root is same, if not -> return false
4. leftsubtree arrays = constructed from smaller elements than root
5. rightsubtree arrays = constructed from greater elements than root
6. if leftsubtree == rightsubtree -> return true
7. For finding result in step 6, follow above steps recursively

Code: While writing code, I am skipping the element equal to root.

Ruby:

def checkidenticaltree(a, b)
   return false if a.length != b.length
   return false if a[0] != b[0]
   return true if a.length <= 1

   a_left  = a.select {|v| v < a[0]}
   a_right = a.select {|v| v > a[0]}
   b_left  = b.select {|v| v < b[0]}
   b_right = b.select {|v| v > b[0]}

   return checkidenticaltree(a_right, b_right) && checkidenticaltree(a_left, b_left)   
end

Python:

def checkidenticaltree(a, b):
   if len(a) != len(b):
       return False
   if a[0] != b[0]:
       return False
   if len(a) <= 1:
       return True

   a_left  = []
   a_right = []
   for x in a:
       if x < a[0]:
           a_left.append(x)
       elif x > a[0]:
           a_right.append(x)

   b_left  = []
   b_right = []
   for x in b:
       if x < b[0]:
           b_left.append(x)
       elif x > b[0]:
           b_right.append(x)
    
   return checkidenticaltree(a_right, b_right) and checkidenticaltree(a_left, b_left)

PS: This is not a very efficient approach as we have to segment stream on each recursion. It will be great, if we can find some bottom-up approach. Any suggestions?

At Slideshare, we use Amazon Web Services offerings and our main usage are of EC2, SQS and S3. We host almost all of our content at S3 because of scalability and reliability, it provides. For interacting with S3 via ruby, we use right_aws gem from Rightscale.

For finding a link for a private S3 object, we use get_link() method in right_aws. By default, get_link() returns a link, which remains valid for 24 hours. This is because default expiry time is set to 24 hours.

DEFAULT_EXPIRES_AFTER  =   1 * 24 * 60 * 60 # One day's worth of seconds

expires ||= DEFAULT_EXPIRES_AFTER
expires   = Time.now.utc + expires if expires.is_a?(Fixnum) && (expires < ONE_YEAR_IN_SECONDS)
expires   = expires.to_i

link = @s3_helper.get_link(bucket, key, expires = 30 * 24 * 60 * 60)

link = @s3_helper.get_link(bucket, key, expires = Time.now.utc + 366 * 24 * 60 * 60)

I had to convert ttf fonts in Base64 encoding and save them in CSS while doing some more complex stuff. I wrote a python script for it using inbuild base64 library, which worked pretty fine.

I did the same in ruby (with inbuild Base64 library) and my code ran without any error. So far so good! But when I saw the results in browser, I was surprised to see that it replaced the actual glyphs with random glyphs. Since python script output was doing good job, I was surprised, what I did wrong.

When I run the base64 encoding on a shorter string, I noticed the difference in results.

Ruby Run:

irb(main):010:0* require 'base64'
=> false
irb(main):011:0> str="Akash is testing Base64 Encoding between python and ruby"
=> "Akash Agrawal is testing Base64 Encoding between python and ruby"
irb(main):012:0> Base64.encode64(str)
=> "QWthc2ggaXMgdGVzdGluZyBCYXNlNjQgRW5jb2RpbmcgYmV0
     d2VlbiBweXRo\nb24gYW5kIHJ1Ynk=\n"

>>> import base64
>>> str="Akash is testing Base64 Encoding between python and ruby"
>>> base64.b64encode(str)
'QWthc2ggaXMgdGVzdGluZyBCYXNlNjQgRW5jb2RpbmcgYmV0
   d2VlbiBweXRob24gYW5kIHJ1Ynk='

irb(main):018:0> Base64.encode64(str).gsub("\n", '')

We have learnt a tip for writing faster ruby code and profiling ruby in last past. Today we will see a few more tips to write faster ruby code.

Tip #2: Avoid Temporary Objects:
Consider following ruby code, how can we make it fast?

#!/usr/bin/env ruby
require 'benchmark'

a = ""
1_000_00.times { a += "." }

#!/usr/bin/env ruby
require 'benchmark'

a = ""
1_000_00.times { a << "." }

“akashagrawal”.gsub
“akashagrawal”.sub
“akash” + “agrawal”
[1, 2].collect
[1, 2].compact
[1, 2].uniq
[1 , [2, 3]].flatten
[1] + [2]

“akashagrawal”.gsub!
“akashagrawal”.sub!
“akash” << “agrawal”
[1, 2].collect!
[1, 2].compact!
[1, 2].uniq!
[1 , [2, 3]].flatten!
[1].concat[2]

Developers usually feel that ruby is a slow language in terms of time efficiency. This is true but if you use some tricks, your ruby code can run faster. I am giving you some tips (with example) to optimize your ruby code and you can see the results in practice.

How to profile: To know, where to make changes in your code to run faster, you need to profile your code. You can use inbuild “benchmark” library or Ruby-Prof for this purpose. Though there are many other tools, but I found these 2 very suitable and easy to use. Ruby-Prof gives you output in multiple formats so that you can analyze it easily.

Tip #1 :- Printing

Consider following ruby code, how can we make it fast?

require 'benchmark'

n = 50_000

for i in 1..n do
  $stderr.print i, "and"
  $stderr.puts i
end

1. We are using 2 distinct functions calls (puts and print).
2. We are using ‘puts’, which includes the overhead of adding a ‘\n’ to every line that doesn't already have one.

require 'benchmark'

n = 50_000

Benchmark.bmbm(15) do |r|

  r.report("original version 2 calls") do
      for i in 1..n do
          $stderr.print i, "and"
          $stderr.puts i
      end
  end

  r.report("single puts call") do
      for i in 1..n do
          $stderr.puts "#{i} and #{i}"
      end
  end

  r.report("single print call") do
      for i in 1..n do
          $stderr.print "#{i} and #{i}\n"
      end
  end

end

akash$ ruby puts_print.rb 2> /dev/null
Rehearsal ------------------------------------------------------------
original version 2 calls   0.370000   0.260000   0.630000 (  0.639098)
single puts call           0.250000   0.140000   0.390000 (  0.397769)
single print call          0.170000   0.070000   0.240000 (  0.256804)
--------------------------------------------------- total: 1.260000sec

                             user     system      total        real
original version 2 calls   0.380000   0.270000   0.650000 (  0.658632)
single puts call           0.240000   0.140000   0.380000 (  0.390004)
single print call          0.170000   0.070000   0.240000 (  0.250661)

var = true

#it wasn't working
if var == 1
Flsuh_data_from_Cache
end 

var = true

#it worked
if var
Flsuh_data_from_Cache
end 

Last week I was debugging a problem for our production servers. The code there is in ruby.

I encountered following lines while debugging:

suffixes= “some string”

suffixes.each do |suffix|

Do some operation on suffix

end

After reading this code, I was pretty surprised how this is running properly, coz each operation is for arrays and here ‘suffixes’ is a string. (Actually ‘suffixes’ was supposed to be an array but in few test cases, it was coming as string.) I tried to run the same code on my local machine and it threw following error on my face.

NoMethodError: undefined method `each' for "akash":String

from (irb):13

I was very much surprised with the different results on my local machine and on server. Then I checked the version of ruby installed on both the machines and that disclosed the mystery. On the server, it was 1.8.6 and that was working fine (though wrong). While on my local machine it was 1.9.2dev, this bug seems to be corrected in new version.

A few days ago, we were planing to upgrade to new version of ruby, but after this incidence, we pushed our plans for some time. These kinds of errors will make our life hell until we have a thorough investigation of such differences between the two versions.