static VALUE
rb_str_strip(VALUE str)
{
    char *start;
    long olen, loffset, roffset;
    rb_encoding *enc = STR_ENC_GET(str);

    RSTRING_GETMEM(str, start, olen);
    loffset = lstrip_offset(str, start, start+olen, enc);
    roffset = rstrip_offset(str, start+loffset, start+olen, enc);

    if (loffset <= 0 && roffset <= 0) return rb_str_dup(str);
    return rb_str_subseq(str, loffset, olen-loffset-roffset);
}

#strip

How do Ruby methods work?

code

# hello_ruby_hack.rb

def say_hello(name)
   puts "Hello, #{name}!"
end

say_hello("Ruby HACK")

tokens

require 'ripper'

file = File.read('hello_ruby_hack.rb')

# tokens are chunks of code
# and don't need to be executable

Ripper.tokenize(file)

=> ["def",
 " ",
 "say_hello",
 "(",
 "name",
 ")",
 "\n",
 "   ",
 "puts",
 " ",
 "\"",
 "Hello, ",
 "\#{",
 "name",
 "}",
 "!",
 "\"",
 "\n",
 "end",
 "\n",
 "\n",
 "say_hello",
 "(",
 "\"",
 "Ruby HACK",
 "\"",
 ")",
 "\n"]

AST

abstract syntax trees

require 'ripper'

file = File.read('hello_ruby_hack.rb')

# sexp is short for symbolic expression

Ripper.sexp(file)

=> [:program,
 [[:def,
   [:@ident, "say_hello", [1, 4]],
   [:paren, [:params, [[:@ident, "name", [1, 14]]], nil, nil, nil, nil, nil, nil]],
   [:bodystmt,
    [[:void_stmt],
     [:command,
      [:@ident, "puts", [1, 21]],
      [:args_add_block,
       [[:string_literal,
         [:string_content,
          [:@tstring_content, "Hello, ", [1, 27]],
          [:string_embexpr, [[:var_ref, [:@ident, "name", [1, 36]]]]],
          [:@tstring_content, "!", [1, 41]]]]],
       false]]],
    nil,
    nil,
    nil]],
  [:method_add_arg,
   [:fcall, [:@ident, "say_hello", [1, 50]]],
   [:arg_paren,
    [:args_add_block,
     [[:string_literal, [:string_content, [:@tstring_content, "Ruby HACK", [1, 61]]]]],
     false]]]]]

bytecode

file = File.read('hello_ruby_hack.rb')
instructions = RubyVM::InstructionSequence.compile(file)

# since Ruby 1.9, bytecode is read by VM
# instead of the traversing the AST

puts instructions.disassemble

== disasm: #<ISeq:<compiled>@<compiled>>================================
0000 trace            1                                               (   1)
0002 putspecialobject 1
0004 putobject        :say_hello
0006 putiseq          say_hello
0008 opt_send_without_block <callinfo!mid:core#define_method, argc:2, ARGS_SIMPLE>, <callcache>
0011 pop
0012 trace            1                                               (   5)
0014 putself
0015 putstring        "Ruby HACK"
0017 opt_send_without_block <callinfo!mid:say_hello, argc:1, FCALL|ARGS_SIMPLE>, <callcache>
0020 leave
== disasm: #<ISeq:say_hello@<compiled>>=================================
local table (size: 2, argc: 1 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1])
[ 2] name<Arg>
0000 trace            8                                               (   1)
0002 trace            1                                               (   2)
0004 putself
0005 putobject        "Hello, "
0007 getlocal_OP__WC__0 2
0009 tostring
0010 putobject        "!"
0012 concatstrings    3
0014 opt_send_without_block <callinfo!mid:puts, argc:1, FCALL|ARGS_SIMPLE>, <callcache>
0017 trace            16                                              (   3)
0019 leave                                                            (   2)

bytecode

(This is only true for CRuby.)

What is Ruby Racing?

$ gem install ruby-racer

$

#flatten_race.rb

require 'ruby_racer'
require_relative 'flatten'

What makes code faster?

primitive

operations

are fast

# max with each enumerable

def max(array)
    # (...)
    array.each do |el|
	max = el if el > max
    # (...)
end

# max with while loop

def max(array)
    # (...)
    while i < arr.length
        if array[i] > max
   	    max = array[i]
    # (...)
end

# benchmark

iterations = 1000000
input = [ 1, 2, 3 ]
operation = el + el

		user	    total	real
with each:      0.2500	    0.2500	(0.251002)
with while:     0.2200	    0.2200	(0.226902)

array mutation

is costly

# array appending vs assignment

[] << 1

[nil][0] = 1

# => [1]

# benchmark

iterations = 1000000

		user	    total        real
with append:    0.1000	    0.1000	 (0.096824)
with assign:    0.0900	    0.0900	 (0.095280)

complex algorithms

are slow

dive into

source code

How do we define code quality?

• readability
• testability
• scalability

What is Ruby best at?

• good for beginners
• lots of included libraries
• lots of OSS libraries
• easy to debug
• easy to compile
• frameworks
• cool logo