Musings of a restless programmer: February 2013

Wednesday, February 6, 2013

Adding code snippets to your blog

When writing technical articles about programming, one needs to add code snippets for reference from time to time. The following post highlights two methods I find both simple and easy to use.

Github Gist

Think of a Gist as a single source controlled file that can be edited, cloned and shared easily. This is one of my favorite options for sharing small code snippets. It has the added advantage of being version controlled as well.

Instructions
1- Head on over to gist.github.com
2- If you have a github account (which you should) sign in. Start by adding a file name for your gist; the syntax highlighting will automatically be detected by the extension:

3- Make sure to create the gist as "public". Once you do so, you'll see a "embed this gist" link ont he left hand side in the following format:
<script src="https://gist.github.com/<user_id>/<gist_id>.js"/>

4- Copy that and embed it in your blog. Here is an example with some ruby code:

	# Array Method for computing fibbonacci number
	def fib(n)
	return n if n < 2
	vals = [0, 1]
	(n-1).times do
	vals.push(vals[-1] + vals[-2])
	end
	return vals.last
	end

	# Test it out
	10.times do \|i\|
	puts fib(i)
	end

view raw gist_test.rb hosted with ❤ by GitHub

SyntaxHighlighter

If you don't want to bother with an external service and you'd rather host your code as part of your site, there is another popular option called SyntaxHighlighter. It's essentially a set of javascripts you can add to your blog/website to easily display syntax-highlighted code in a variety of languages.

Instructions
(based on original instructions from Alex Shirmanov)
1- Go to your blog's html source and add the following in your <head> section.

<!-- SyntaxHighlighter -->
<!-- 1- Core javascript and css -->
<link href='http://alexgorbatchev.com/pub/sh/current/styles/shCore.css' rel='stylesheet' type='text/css'/> 
<link href='http://alexgorbatchev.com/pub/sh/current/styles/shCoreDefault.css' rel='stylesheet' type='text/css'/> 
<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeDefault.css' rel='stylesheet' type='text/css'/> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shCore.js' type='text/javascript'/> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shAutoloader.js' type='text/javascript'/> 
  
<!-- 2- Brushes -->
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushPlain.js' type='text/javascript'/> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushBash.js' type='text/javascript'/> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJava.js' type='text/javascript'/> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushRuby.js' type='text/javascript'/> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushScala.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushXml.js' type='text/javascript'/>  
  
<!-- 3- Activate SyntaxHighlighter -->
<script language='javascript' type='text/javascript'> 
    SyntaxHighlighter.config.bloggerMode = true;
    SyntaxHighlighter.all();
</script>

Note #1: To edit the layout of a blogger blog, go to Template -> Edit Html
Note #2: If you have your own hosting capabilities, you might want to upload these files to your own server

2- Notice that in the brushes section (#2) we are loading various javascripts for different programming language syntaxes. For a full list of what's supported, see here. If you need support for a given language, just add an additional reference to shBrushXXX.js where XXX is the language you want support for.

3- We're now ready to add code snippets to your blog. You can do so easily by adding the following html (replacing brush_name with the language of your code snippet):
<pre class="brush: brush_name">
// Enter code here
</pre>

Here is an example with class="brush: scala":

// Hello world in scala
object HelloWorld {
    def main(args: Array[String]) {
      println("Hello, world!")
    }
  }

Happy blogging!

Tuesday, February 5, 2013

Multi-threading in JRuby

The traditional Ruby you might be used to running (along with other interpreted languages such as python) make use of a global interpreter lock which ensures that only one thread can interpret code at any given time. In Ruby 1.8, the process is only allocated one OS thread meaning any attempts at parallelism are basically useless. In Ruby 1.9 things were improved slightly; the GIL still only runs on one thread, but the process can take advantage of multiple threads. This means that anything I/O bound can run concurrently (database queries, network requests) but you won't be able to make effective use of the processing power of all of your cores.

JRuby on the other hand, is built upon the JVM. One can make use of "true" native threads which are able to run concurrently with you parent thread.

To visualize how this works check out this diagram:

Read more about the GIL here (from which I borrowed the above diagram).

Setup

Here are some quick instructions on how to setup JRuby on your machine so we can test out multi-threaded performance. The easiest way to install JRuby in my opinion is through Ruby Version Manager. RVM is essentially an easy way to manage multiple ruby versions (and their associated gems) on a single machine. For Linux/Unix/OSX instructions, see here. For windows go here.

1- Install JRuby:
>rvm install jruby

2- Check that it's installed
> rvm list gemsets

3- rvm use <name of the jruby gemset>
> rvm use jruby-1.7.1

4- Test it out in irb (ruby's interactive console). You should see "java" as the RUBY_PLATFORM if things are installed properly:

Sample App

The following are two sample apps which showcase multi-threading in JRuby vs. Ruby 1.9 vs Ruby Enterprise Edition 1.8.7.

JRuby Example (also showcasing how easy it is to call java code from Ruby):

	# used to call java code
	require 'java'

	# 'java_import' is used to import java classes
	java_import 'java.util.concurrent.Callable'
	java_import 'java.util.concurrent.FutureTask'
	java_import 'java.util.concurrent.LinkedBlockingQueue'
	java_import 'java.util.concurrent.ThreadPoolExecutor'
	java_import 'java.util.concurrent.TimeUnit'

	# Implement a callable class
	class CountMillion
	include Callable
	def call
	count = 0
	1000000.times do
	count += 1
	end
	end
	end

	# Create a thread pool
	executor = ThreadPoolExecutor.new(4, # core_pool_treads
	4, # max_pool_threads
	60, # keep_alive_time
	TimeUnit::SECONDS,
	LinkedBlockingQueue.new)

	# Try counting to 1 million on 4 separate threads 20 times
	num_tests = 20
	num_threads = 4
	total_time = 0.0

	num_tests.times do \|i\|
	tasks = []

	t_0 = Time.now
	num_threads.times do
	task = FutureTask.new(CountMillion.new)
	executor.execute(task)
	tasks << task
	end

	# Wait for all threads to complete
	tasks.each do \|t\|
	t.get
	end
	t_1 = Time.now

	time_ms = (t_1-t_0) * 1000.0
	puts "TEST #{i}: Time elapsed = #{time_ms}ms"
	total_time += time_ms
	end
	executor.shutdown()

	puts "Average completion time: #{total_time/num_tests}"

view raw multi_thread_jruby.rb hosted with ❤ by GitHub

Standard Ruby example:

	num_iterations = 20
	num_threads = 4

	# Try counting to 1 million on 4 separate threads 20 times
	total_time = 0.0
	num_iterations.times do \|iter\|
	threads = []
	t_0 = Time.now
	for i in 1..num_threads
	threads << Thread.new(i) { \|t\|
	count = 0
	1000000.times do
	count += 1
	end
	}
	end

	# Wait for all threads to complete
	threads.each { \|thread\| thread.join }
	t_1 = Time.now

	time_ms = (t_1-t_0) * 1000
	puts "TEST #{iter}: Time elapsed = #{time_ms}ms"
	total_time += time_ms
	end

	puts "Average completion time: #{total_time/num_iterations}"

view raw multi_thread_ruby.rb hosted with ❤ by GitHub

To run the experiment:
1- Run in Jruby:
> ruby multi_thread_jruby.rb

2- Run in Ruby 1.9.3
> rvm install ruby-1.9.3-p286
> rvm use ruby-1.9.3-p286
> ruby multi_thread_ruby.rb

3- Run in Ruby 1.8.7
> rvm install ree-1.8.7-2012.02
> rvm use ree-1.8.7-2012.02
> ruby multi_thread_ruby.rb

Average completion time summary:
JRuby(1.7.1): 199.3ms
Ruby(1.9.3p286): 610.0ms
Ruby(ree-1.8.7-2012.02): 748.6ms

As we can see, JRuby is close to 4 times faster than Ruby 1.8 on my 4 core MacBook Air. Ruby 1.9 performs slightly better by being able to take advantage of time during which the process is I/O blocked. Overall, JRuby is the clear choice for maximizing multi-threaded performance.

Additional Reading:

More on calling Java from JRuby:
https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby

An interesting look at benchmarks of JRuby compared to other ruby versions. This shows that JRuby is not better in all scenarios:
http://etehtsea.me/the-great-ruby-shootout

#SeekDiversePerspectives