Programming With Ruby, Feedback


Covered In This Episode:

  • $1000 or 1000 comments
  • Submit to Social Media


Hello Everybody and welcome to Programming With Ruby, Feedback. I’m
Tyler, and this video is brought to you by

In this video I’m going to be going over what needs to happen for me
to produce the next series of video tutorials.

All links I mention will be in the video description

First things first, if you head on over to

You can vote on what the next video series will be.

So if you vote I will know what YOU want, now you need to know what I
want for the next series to happen.

I’ve had well over 1,000 unique viewers of this video series, so I
need you viewers to donate a total of $1000 before I make the next
series. This may seem like a high amount, but if only 200 people
donate $5, that is a thousand dollars.


Now, what if you don’t have the money to donate? I will be making a
post on named Ruby Video Tutorial Feedback, if 1000
people leave feedback (i.e. What they liked, what they didn’t like).

So whatever comes first, 1000 comments or $1000 will cause me to start
the next video series.

For updates on how close we are to each goal, I will be on twitter at
the account tylerjchurch and with the tag #manwithcode.

Now what if you can’t donate money, and you can’t write me feedback?
Then there is something else you can do!

  • Tweet on Twitter
  • Give a thumbs up on StumbleUpon
  • Submit to Digg
  • Submit to Reddit
  • Bookmark on delicious
  • Blog about
  • or you can just Tell a friend

And hopefully one of those people who come along will donate or leave

So don’t forget to donate, leave feedback, or submit the provided link
to social media!

Thanks for watching, bye!

Programming With Ruby Episode 18, Out Into The World

Covered In This Episode:

  • Where to go from here
  • Books
  • Libraries
  • A few other things…


Hello Everybody and welcome to Programming With Ruby Episode 18, Out
Into The World. I’m Tyler and this video is brought to you by

In this episode I will be telling you where to go from here, now that
you know the basics of Ruby. I’ll show you some books, some common
libraries. And I’ll go over a few more things.

Where to go from here

Now that this series is almost done, you may be wondering what you
should do. First, I recommend you start writing your own
programs. Find something you would like to write and just try writing

You may also want to read a few other resources like books and online
tutorials about Ruby for things I didn’t cover and to reinforce what
you have learned.

For books I would recommend:

  • Beginning Ruby, From Novice to Professional
  • The Ruby Programming Language

If you are trying to make something, but can’t do it with Ruby alone,
here are some libraries in a few common areas. I won’t be providing
links, but a quick Google search will find them for you.

Web Development

  • Ruby on Rails
  • Sinatra
  • Merb

Game Development

  • Rubygame
  • rubysdl
  • Gosu


  • rspec
  • cucumber


  • RMagic

GUI Toolkits

  • Ruby-WxWidgets
  • Ruby-GNOME2
  • Shoes

If you need a library for something I didn’t cover, you can check
Ruby’s documentation at, you can try and find a project
by searching at and If all else fails, just
Google it.

This is actually the end of the episode, but though this video is
purported as the end of the series, there is going to be at least one
more video, so stay tuned.

If you’ve liked this series, please donate!

If you have and questions, comments, or suggestions about this series
or Man With Code, you can leave a comment on this page or email me at

Thanks for watching, goodbye!

Programming With Ruby Episode 17, Getting Advanced

Covered In This Episode:

  • Symbols
  • eval
  • Bindings
  • Running Other Programs
  • Safe Levels


Hello Everybody and welcome to Programming With Ruby Episode 17,
Getting Advanced. I’m Tyler, and this video is brought to you by

By now, you know a large amount about Ruby, so in this episode we will
be going over some advanced features that Ruby has.

More specifically I will be teaching you what Symbols are, and when to
use them. I will be showing you how to use eval, and how to use
bindings with eval. You will learn how to run other programs from
Ruby. Finally I will show you what safe levels are.

Lets get started!


Symbols are a type of variable that are very much like strings, but
more lightweight. Symbols look like this:


Symbols can’t be manipulated like strings can, which seems like a huge
drawback, but they do have a couple benefits.

Each time you use a string, to say access a hash. Ruby creates an
instance of that string. Where if you use a symbol, it is only ever
instanced once. Meaning that the use of symbols will take up less
memory than strings will, if you are, say accessing a hash many times.

Symbols are also slightly easier to type since the colon is on the
home row on US keyboards.


eval is a way of running Ruby code that is contained in a string. For
example, lets say you have a string that looks like this:

"puts 'Hello World'"

It is just a simple string, so it does nothing. But, if you use the
method eval on that string it will execute the code inside. So this
will print Hello World! on to the screen:

eval "puts 'Hello World!'"

This isn’t always useful, but you can use it if you want your users to
be able to enter Ruby code into your program.

You can also pass bindings to eval. So if we had this method

def my_method my_binding
    eval "puts x", my_binding

x = 5
my_method binding

This outputs:


Some of you may notice that the variable x isn’t defined in the method my_method. By using the binding method, we can make variable scopes portable!

Running Other Programs

There comes a time when you will want to be able to run a program from
Ruby, maybe you want to automate something, or simply get the output
from an external program.

There are a few ways of doing this.

The first is with the method exec, which runs an external programs,
and quits the Ruby script at the same time:

exec('ls') # dir on windows
# Program never gets here

There is also system, which does the same thing, but doesn’t quit the
Ruby script, and returns true or false if the program was successful:

system('ls') # dir on windows
# we do get this far

Finally we have the “back-tick” `. Which looks like a sideways single
quote. On my keyboard it is above the tab key. You surround your
command in the back-ticks, like you would for a sting. Unlike the other
two methods of running a program, this method also returns the output
of the program you run.

variable = `ls`

Safe Levels

If you are running a Ruby interpreter online or in another environment
where users can enter in and run Ruby code. They hold the ability to
wreak havoc on your system.

The way to prevent this from happening is by using safe levels. Safe
levels are a way of preventing the user from getting access to the
file system, or changing any variables that the program has.

You set safe levels by setting the $SAFE variable. By default it is
set to zero.

$SAFE = 4

Ruby “taints” objects that could be dangerous.

There are five different safe levels.
0 => The default, you can do anything
1 => Can’t use environment variable, eval, load, require, and more.
2 => Same as above and also can’t use files
3 => All objects created are tainted, can’t be untainted
4 => You can do almost nothing… Can’t modify the untainted, can’t
use exit. Basically completely safe and sand-boxed.

That brings us to the end of the episode. If you liked these videos,
please donate. It costs me in both money and time to make them.

If you have any questions, comments, or suggestions please don’t
hesitate to leave a comment on this page or email me at

Thanks for watching, goodbye!

Programming With Ruby Episode 16, Benchmarking

Covered In This Episode:

  • What is benchmarking?
  • Benchmarking
  • Profiling


Hello Everybody and welcome to Programming With Ruby Episode 16,
Benchmarking. I’m Tyler and this video is brought to you by

In this episode I will tell you what benchmarking is. You will learn
how to preform benchmarking tests on some of your code. And after that
you will learn how to preform the more exhaustive benchmarking process
called profiling.

This should be a very quick and easy episode, so lets get started!

What is benchmarking?

Basically benchmarking is measuring how fast your code runs. Whether
that means your code as a whole or only parts of it. This can be
useful so you can optimize your code to run faster, in the places it
is running the slowest. Benchmarking is also commonly used to compare
two different programs in the category of speed, which can be a
selling point for many products.


To get access to benchmarking make sure you put:

require 'benchmark'

in your code.

The most simple form of benchmarking is Benchmark.measure:

a = Benchmark.measure do
    1_000_000.times do |i|
        x = i

puts a #=> 0.400000   0.140000   0.540000 (  0.537934)

The last number is the actual time it took to run the test.

There is also, which is similar, but adds headings and
allows you to do multiple tests. do |bm|'Test 1:') do
        1_000_000.times do
            x = 1
    end'Test 2:') do
        1_000.times do
            x = "Moo..."

# Example Output:
#          user     system      total        real
# Test 1:  0.430000   0.120000   0.550000 (  0.563787)
# Test 2:  0.000000   0.000000   0.000000 (  0.000775)

Then there is Benchmark.bmbm, which is exactly the same as bm, but
preforms a benchmark twice.

Example Benchmark.bmbm Output:
Rehearsal -------------------------------------------
Test 1:   0.370000   0.110000   0.480000 (  0.484865)
Test 2:   0.000000   0.000000   0.000000 (  0.000529)
---------------------------------- total: 0.480000sec

user     system      total        real
Test 1:   0.390000   0.090000   0.480000 (  0.477402)
Test 2:   0.000000   0.000000   0.000000 (  0.000529)

And that is all there is to know about simple benchmarking, on to


Profiling takes benchmarking to the extreme. It tells you how much time each part of your code is take, and all you have to do is put:

require 'profile'

at the top of your program!

require 'profile'

class MyMath
    # Don't worry about the math, just the profiling output
    # We repeat the code to make it use up more time
    def self.x_offset angle, distance
        1000.times { distance * Math.sin(angle * Math::PI/180) }

    def self.y_offset angle, distance
        1000.times { distance * Math.cos(angle * Math::PI/180) * -1 }

MyMath.x_offset(220, 50)
MyMath.y_offset(220, 50)

And from the profiling output, we can see what took the longest:

%   cumulative   self              self     total
time   seconds   seconds    calls  ms/call  ms/call  name
72.41     0.21      0.21        2   105.00   145.00  Integer#times
10.34     0.24      0.03     4000     0.01     0.01  Fixnum#*
6.90     0.26      0.02     1000     0.02     0.02  Math.cos
6.90     0.28      0.02     2000     0.01     0.01  Float#/
3.45     0.29      0.01     1000     0.01     0.01  Float#*
0.00     0.29      0.00        1     0.00   140.00  MyMath#y_offset
0.00     0.29      0.00        1     0.00   150.00  MyMath#x_offset
0.00     0.29      0.00        1     0.00     0.00  Class#inherited
0.00     0.29      0.00     1000     0.00     0.00  Math.sin
0.00     0.29      0.00        2     0.00     0.00  Kernel.singleton_method_added
0.00     0.29      0.00        1     0.00   290.00  #toplevel

And that is it for today’s episode!

Please do not forget to show your appreciation by donating.

If you have any thing to say about anything related to Man With Code
or these videos, please leave a comment below, or email me at

Thanks for watching, Bye!