Covered In This Episode

• I’m sorry
• Why I’ve been gone
• Making Games with Ruby update
• Thank you donators!

Covered In This Episode:

• Creating a Window
• Basic Event Handling

Transcript:

Hello Everybody and welcome to making games with Ruby episode 3, Basics. I’m Tyler and these videos are brought to you by manwithcode.com.

Today we’re just going to be talking about the very basics of game creation, just getting a window on the screen. The code for this episode is on manwithcode.com, if you’re not there already. http://manwithcode.com/322/making-games-with-ruby-ep-3-basics

Lets get started!

We’re going to start by requiring in the libraries we need, which for now is only rubygems and rubygame:

require 'rubygems'
require 'rubygame'

Then we’re going to create the main Game class, and stub out all the methods in it:

class Game
	def initialize
	end

	def run!
	end

	def update
	end

	def draw
	end
end

And after that we’re going to add the code to run the game:

g = Game.new
g.run!

So far this is just some very basic structure, nothing really happens yet. I’m going to run the code just to double check we have no syntax errors…

The first thing we’re going to do is initialize everything we’ll need:

def initialize
	@screen = Rubygame::Screen.new [640, 480], 0, [Rubygame::HWSURFACE, Rubygame::DOUBLEBUF]
	@screen.title = "Pong"

	@queue = Rubygame::EventQueue.new
	@clock = Rubygame::Clock.new
	@clock.target_framerate = 60
end

Some of this is self explaitory, but let’s break it down. The first line of initialize creates the window for our game, Rubygame calls this a Screen. The first argument [640, 480] is the size of the screen, the second is the screen depth (you don’t need to worry about this), the last one is a list of flags we pass to rubygame. HWSURFACE means we want it to be accelerated on the graphics card if available, and DOUBLEBUF means we want the screen to be double buffered. Double buffering is a way of drawing to the screen. I won’t go into too much detail right now to explain double buffering, but I will in a later episode.

The second line has an obvious purpose, it sets the title at the top of the screen to Pong

The fifth line is setup so we can handle events, I’ll talk more about this later.

The last two lines are the setup so we can limit the framerate to 60 frames per second. The frame rate is how many times the screen is drawn every second (we’ll be doing our drawing in the Game#draw method). If we let this go unchecked, our game will run as fast as possible which isn’t desireable since top speed will be different on different computers, and depending on what the game is doing at a particular moment in time. I think 60 is a good number, but we can easily change it later if we want.

Next we’re going to setup the main game loop:

def run!
	loop do
		update
		draw
		@clock.tick
	end
end

This loops indefinately until we decide in a different part of the code to end the game. @clock.tick is what allows us to limit our framerate. You can now run the game, it should just be a black screen. You can see the title at the top, like we set in the initialize function.

But if you try to close the window… Nothing happens!!! To close it try pressing CTRL+C in the command prompt window, or you may have to go to the task manager and kill it from there. To fix this problem, we need to talk about the event queue.

We’re going to start by defining the update method:

def update
	@queue.each do |ev|
		case ev
			when Rubygame::QuitEvent
				Rubygame.quit
				exit
		end
	end
end

Whenever the user gives us some input, presses a key, moves the mouse, etc. the Rubygame adds an event for this input onto the queue. We handle these events in our update method.

@queue.each loops over each event, and we have a case statement that handles the event depending on the type. For closing the window, the event type is Rubygame::QuitEvent, which is generated whenever the user presses the close window button or ALT+F4.

Now if you run the game, the window should appear and you should be able to close it now! Yay!

This is the final source listing for this episode:

require 'rubygems'
require 'rubygame'

class Game
	def initialize
		@screen = Rubygame::Screen.new [640, 480], 0, [Rubygame::HWSURFACE, Rubygame::DOUBLEBUF]
		@screen.title = "Pong"

		@queue = Rubygame::EventQueue.new
		@clock = Rubygame::Clock.new
		@clock.target_framerate = 60
	end

	def run!
		loop do
			update
			draw
			@clock.tick
		end
	end

	def update
		@queue.each do |ev|
			case ev
				when Rubygame::QuitEvent
					Rubygame.quit
					exit
			end
		end
	end

	def draw
	end
end

g = Game.new
g.run!

This brings us to the end of the episode.

If you have any questions, comments, or suggestions, leave a comment on this page or email me at tyler@manwithcode.com.

Thank you very much for watching! Goodbye!

gem install rubygame

Mac:

Linux:

sudo apt-get install -y libsdl1.2debian libsdl1.2-dev libsdl-image1.2 libsdl-image1.2-dev libsdl-ttf2.0-0 libsdl-ttf2.0-dev libsdl-mixer1.2 libsdl-mixer1.2-dev libsdl-gfx1.2-4 libsdl-gfx1.2-dev

sudo gem install rubygame

Links:

• Rubygame Installation guides
• Rubygame windows dependencies

Covered in This Episode:

• How to get set up for this series on Windows, Mac, and Linux

Links:

• Programming with Ruby Video Tutorials

Covered In This Episode:

• What you’ll learn
• What we’re using
• What I’m assuming about you
• Why I’m teaching this

Transcript:

Hello Everybody, and Welcome to the first episode of Making Games With Ruby! I’m Tyler, and this video is brought to you by manwithcode.com

In this episode I’ll be covering what you will be learning in this series, what we’re using to develop our games, what I’m assuming about you, and why I’m teaching you.

What you’ll learn

If you couldn’t tell by the title, you’re going to learn how to make games using the Ruby programming language. More specifically I’m going to teach you how to make Pong. Though Pong may sound a little simplistic, and I’m not claiming it isn’t, learning how to make Pong will teach you almost everything you’ll need to know to make any game, with out getting bogged down in game specific details.

What we’re using

Of course we’re using the Ruby programming language. To create games, we’ll have the help of the Rubygame library, which is many things including a wrapper around SDL, and a nice framework for developing games.

In the creation of this series I will be using Ruby 1.8.7-p174, and Rubygame 2.6.2. Theoretically The code in this series should run on Ruby 1.8.whatever and Rubygame 2.whatever, no promises though, since languages and libraries change.

And if you want to know about my environment, I’ll be running Ubuntu 9.10 as my Operating System, and using Gedit as my text editor. You can write and run the code on any platform you wish, but this is what I prefer.

What I’m assuming about you

So I don’t have to explain every line of code to you, I’m going to be assuming that you already know the Ruby programming language. If you don’t there are many books available, as well as my own video series Programming With Ruby at http://manwithcode.com/ruby-programming-tutorials/

Just reading one book, or watching my video series probably isn’t enough. I’ll be easier if you have used Ruby for a while, and are comfortable with it. This isn’t
a requirement, but it would help make things easier on yourself.

Why I’m teaching this

There are many reasons why, but I’ll talk about the most important few:

1) I love making games.
2) I love teaching.
3) Teaching teaches me something. – When you actually sit down and think about what you do, things become more concrete, and you know why you do what you do, or even see bad habits that you need to correct
4) I’m trying to make money – Yep, I’m not going to try and hide this. Some of the videos in this series will be put up for sale, you’ll be able to see them as I put out more videos.

Thank you very much for watching! I’ll see you in the next video.

Links:

• Donate: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=4222118
• Submit This Link: http://manwithcode.com/ruby-programming-tutorials/
• Vote: http://manwithcode.com/tutorials-under-consideration/
• Leave Feedback Here: http://manwithcode.com/235/leave-feedback-here-programming-with-ruby-feedback/

Covered In This Episode:

• $1000 or 1000 comments
• Submit to Social Media

Transcript:

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

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
http://manwithcode.com/tutorials-under-consideration/

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.

Donate: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=4222118

Now, what if you don’t have the money to donate? I will be making a
post on manwithcode.com 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!
http://manwithcode.com/ruby-programming-tutorials/

• 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
feedback.

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

Thanks for watching, bye!

Covered In This Episode:

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

Transcript:

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
manwithcode.com.

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
it.

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

Testing

• rspec
• cucumber

Images

• 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 ruby-doc.org, you can try and find a project
by searching at rubyforge.org and github.com. 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
tyler@manwithcode.com

Thanks for watching, goodbye!

Covered In This Episode:

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

Transcript:

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

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

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

:variable

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

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
end

x = 5
my_method binding

This outputs:

5

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
tyler@manwithcode.com

Thanks for watching, goodbye!

Covered In This Episode:

• What is benchmarking?
• Benchmarking
• Profiling

Transcript:

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

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.

Benchmarking

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
    end
end

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 Benchmark.bm, which is similar, but adds headings and
allows you to do multiple tests.

Benchmark.bm do |bm|
    bm.report('Test 1:') do
        1_000_000.times do
            x = 1
        end
    end
    bm.report('Test 2:') do
        1_000.times do
            x = "Moo..."
        end
    end
end

# 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.

Profiling

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) }
    end

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

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
tyler@manwithcode.com

Thanks for watching, Bye!

Covered in this Episode:

• What are errors
• What is error handling
• begin…end
• rescue
• ensure
• raise

Transcript:

Hello Everybody and welcome to Programming With Ruby Episode 15, Error
Handling. I’m Tyler and this video is brought to you by
manwithcode.com.

In this episode you will learn what exactly errors are, and what error
handling is. You will also be learning how to use the begin…end,
rescue, and ensure keywords, as well as the raise method.

Lets get started!

What are Errors?

There are two types of problems with programs. #1 is bugs, and #2 is
errors. You’ve most likely heard of both of these types of problems
before. But what are they?

Bugs are more subtle problems, the program still runs and acts
normally, but it may be outputting the wrong data, or messing
something else up. It is completely up to the programmer to find these
bugs.

Errors actually stop the program from running, or at least running all
the way through. There are ways of handling most types of errors,
which you will be learning about in this episode.

What is error handling?

It is possible to catch some types of errors, which when left alone,
would otherwise result in your program crashing.

Error handling is the process of catching those errors, and usually
doing something about them, like informing the user, or executing on a
contingency plan.

There are many things that can create errors, such as trying to read
from a file that doesn’t exist, a user entering bad data, trying to
call a method that does not exist, and the list goes on.

Some errors you can combat by using methods like File.exists? to check
if a file exists before trying to open it. But there are other cases
where this is not an option, or where you prefer to handle the problem
a different way. In this episode I will show you how.

Real Code

Error handling starts with the begin…end block which looks like this:

begin
    # Code here
end

In that block is where you put the code that has the possibility of
generating an error. That block in itself doesn’t do anything, to
actually handle the errors, you need to use the rescue keyword.

begin
    # Possibly error inducing code here
rescue
    # What to do if an error happens
end

What ever is between “rescue” and “end” will be executed if an error
occurs. But what if you have the potential for multiple errors? Then
you must use multiple rescues specifying the error the handle:

begin
    # Possibly error inducing code
rescue ArgumentError
    # If ArgumentError is raised
rescue NoMethodError
    # If NoMethodError is raised
end

What if you don’t know the exact name of the error? Either create the
error yourself and look at the output when the program crashes. Go to
http://ruby-doc.org and find all classes ending Error. Or consult
http://www.zenspider.com/Languages/Ruby/QuickRef.html#34

Now lets say you want something to happen regardless of whether or not
the code generates an error. Say maybe you have to close a file, or
end your connection to a database. Then you would want to use ensure!

begin
    # ...
rescue
    # ...
ensure
    # This gets executed no matter what
end

Now that you know how to handle errors, how do you go about raising
errors of your own? With raise, of course!

def mymethod data
    if data.is_malformed?
        raise ArgumentError
    end
end

Why would you want to do this? It can serve as a better reminder to
you or other programmers using your code that what they were doing is
wrong. This can help stop bugs.

This brings us to the end of the episode.

If you have any questions, comments, or suggestions about anything
related to Man With Code or these video tutorials; Please leave a
comment below, or email me at tyler@manwithcode.com

Do not forget to donate. A lot of time and hard work went into making
these. If you liked these videos the best way to show your
appreciation is by donating.

Thanks for watching, goodbye!

Covered in this Episode:

• What is YAML
• Why should you use YAML?
• Storing Data

Transcript:

Hello Everybody and welcome to Programming With Ruby Episode 14,
YAML. I’m Tyler and this video is brought to you by manwithcode.com.

I will start off this episode telling you what YAML is and why you
should be using it. I will then be showing you how you can store
objects and various assorted other kinds of data using YAML.

Without further delay, lets get started!

What is YAML?

YAML stands for YAML Ain’t Markup Language. In the most basic sense it
is a way of storing data for later use.

Why should you use YAML?

Lets say you are writing a game, you could save your players progress
to a YAML file. Or if your writing an application with many preference
settings, you might save the user’s preferences to a YAML file.

Using YAML instead of creating your own text-based format creates more
portability, because other applications can immediately use your YAML
file instead of having to write their own custom file loader.

YAML also makes editing files by hand very easy to do if you have to.

Enough of all the theoretical talk, lets write some code!

Storing Data

Lets say we are writing a text editor and there are a few preferences the
user can change. We want the user to be able to set their preferences and
have them saved, so the next time they start up our text editor the
preferences are set the same as they were at last use.

We decide to use YAML to store our users preferences. Lets say for
example that the preferences are stored in a hash:

@preferences = {"word-wrapping" => true, "font-size" => 20, "font" => "Arial"}

To save that using YAML we have to use:

require 'yaml'

Open a file for writing (YAML files end in .yml or .yaml):

output = File.new('prefs.yml', 'w')

Use the YAML.dump method to get the text that will be outputted:

output.puts YAML.dump(@preferences)
output.close

Full source:

require 'yaml'
@preferences = {"word-wrapping" => true, "font-size" => 20, "font" => "Arial"}

output = File.new('prefs.yml', 'w')
output.puts YAML.dump(@preferences)
output.close

And that is how easy it is to store data!

We read back a file in a similar way, using the YAML.load method:

require 'yaml'

output = File.new('prefs.yml', 'r')
@preferences = YAML.load(output.read)
output.close

Don’t think you’re limited to simple data like hashes and arrays, you
can store objects too!

It has been my experience that it is usually best to store data in
hashes, because they automatically have a label, unlike an array. You
can do whatever you want to, but that is my recommendation.

Now comes the sad time when we have to close the episode.

Please don’t forget to donate, a few dollars can go a long way.

If you have any questions, comments or suggestions, please do not
hesitate to leave a comment below or email me at tyler@manwithcode.com

Thank for watching!

Bye!

Covered in this Episode:

• Defining I/O
• Files
• Directories

Transcript:

Hello Everybody and welcome to Programming With Ruby Episode 13, Basic
input output. As always, I’m Tyler and this video is brought to you by
manwithcode.com

In this episode I will be defining what exactly input/output is, You
will also learn how to work with files and directories in Ruby

Lets get started!

Defining I/O

So what exactly is I/O or input/output. Basically Input is any data that
you receive from the user, and output is what data you give to the
user, usually based on what input the user gave you.

In this episode you will be seeing I/O as working with files and
directories. You have already worked with I/O previously when we
talked about getting strings from the user (gets) and printing string
to the screen (puts)

Files

There are a couple of ways to start working with files. The first is
by using File.new:

my_file = File.new('file', 'r')
my_file.close

File.new opens the file (the first parameter), for the specified mode
(the second parameter)

The file name you use can be either just the relative file name
(notes.txt) or the full path to the file (C:\Documents and
Settings\Tyler\My Documents\notes.txt). Just remember that if you use
only the file name, that file must be in the same folder your program
is located in!

The mode defines how you are going to use the file you’ve opened. In
the example ‘r’ is used. Which stands for read, meaning we are only
going to read from the file.

‘w’ is write meaning we are writing to the file specified, be careful
when using write mode, as the whole file is cleared when it is opened.

‘a’ is append, which is similar to write, except instead of clearing
the whole file, it appends all written data to the end.

All the different modes can have ‘+’ at the end of them, which opens
up both read and write functionality. (ex: ‘w+’)

Now you know how to open a file, how exactly do yo go about writing to
it? By simply using puts and print, like you did when outputting data
to the screen, except they output data to the file!

my_file = File.new('example.txt', 'w')
my_file.puts "Hello World!"
my_file.close

If you want to read from a file you can use File.read:

my_file = File.new('example.txt', 'r')
puts my_file.read
my_file.close

You can also pass in how many characters you want to read as a parameter.

If you would rather have the lines of a file in an array, you can use
file.readlines.

If you are unsure a file exists you can simply use File.exists?:

File.exists("notes.txt")

Now it is important to note that every time I am done using a file I
call the .close method, why do I do this? Because if you don’t close
your access on the file, it can become unusable by other
programs. Also, your computers operating system might not write the
changes you’ve made to the file, until your program has released its
hold on it.

As an alternative to using file.close every single time, we can use
File.open, instead of File.new. File.open lets us use the file in a
code block, at the end of the code block, the file is closed
automatically.

File.open('hello.txt', 'w') do |file|
    file.puts "Hello World!"
end

There is a whole lot more you can do with files in Ruby to learn more
go to http://ruby-doc.org/core-1.8.7/index.html and find the File and IO class

Directories

You can work with directories (also known as folders) in Ruby using
Dir. You can create directories with Dir.mkdir:

Dir.mkdir("Hello")

You can get an array of all the files and directories that are in the
current directory with Dir.entries:

Dir.entries('.')

Keep in mind that . is your current directory, and .. is the directory
one level above the current one. Also, like files you can specify the
relative path or the full path.

There is also another method similar to Dir.entries, Dir.foreach. They
are essentially the same, except foreach allows you to iterate over
each item in a code block.

Dir.foreach('.') do |entry|
    puts entry
end

Like Files, there is a lot of material I couldn’t cover to learn more
go to http://ruby-doc.org/core-1.8.7/index.html and find the Dir class

This brings us to the end of the episode.

If you like these videos please donate.

And if you have any Questions, Comments or Suggestions, you can leave
a comment in the comment box below, or email me at
tyler@manwithcode.com

Thank you very much for watching, goodbye.

Covered In This Episode:

• Comments
• RDoc

Transcript:

Hello Everybody and welcome to Programming With Ruby Episode 12,
Documentation. I’m Tyler and this video is brought to you by
manwithcode.com.

In this episode I will be talking about documenting your code, more
specifically with comments, and using the tool rdoc.

This should be a short show, so lets get started!

Comments

You’ve seen comments throughout these video tutorials. They were the
lines with the hash mark that are ignored by Ruby.

Comments are generally used to explain code to other developers
(including yourself). Ruby already makes code very easy to understand
in the first place. You can also help this by naming your methods and
variables sensibly. But there are times when this is not enough.

Sometimes you end up doing something very complicated, such as a long
regular expression, some SQL magic, or any other possibly difficult to
understand piece of code. Those can be times when comments are needed.

Comments are also needed for when you are making code for other
developers to use. When they are using your code and not developing it
along with you, they can care less about finding how it works. They
just want a comment that can tell them what your class/method/piece of
code/whatever does, and how to make it do it.

Tools like rdoc can help you make your code’s documentation even
better, and that is what we are going to talk about next.

Rdoc

Rdoc should be installed already from when you installed ruby. If not
you can install it via rubygems or your platforms package manager.

Rdoc is a tool that generates very nice looking documentation for your
projects.

First just run the command rdoc in a directory with code files in it.

rdoc will create a folder named “doc” and your documentation will be
that folder. If you go into doc and open up index.html in your
browser, you will see the generated documentation.

You will probably notice that rdoc didn’t pick up any of the comments
inside your code, only those right above the definitions of classes,
methods, or modules.

You may also notice that the descriptions might not be formatted very
well. You can spice it up by using rdoc markup found at:

http://rdoc.rubyforge.org/RDoc.html

I’m not going to go too much farther into rdoc, as it is not an
essential tool for development. It can be, however, very useful. So
please take some time to learn more about it!

This brings us to the end of the show.

Please don’t forget to donate!

If you have any questions, comments, or suggestions you can leave them
in the comment box below or email me at tyler@manwithcode.com

Thank you very much for watching, goodbye!

Covered In This Episode:

• Finding projects (GitHub, RubyForge)
• Using Rubygems
• Using the code

Transcript:

Hello Everybody and welcome to Programming With Ruby Episode 11, Ruby
Projects. I’m Tyler, and this video is brought to you by
manwithcode.com.

Despite what the name may imply, this episode is not about making
projects in ruby, but finding and using projects other people have
made. I will be showing you rubyforge.org and github.com, both places
have many different and useful projects hosted.

I will also be showing you how to use rubygems, arguably the easiest
and most popular way of installing, managing, and keeping up to date
various ruby libraries, tools, etc. which rubygems calls gems.

And finally you will learn how to use the code you find!

Lets get started!

Finding Projects – Rubyforge

Rubyforge is one of the most popular hosting sites for ruby
projects. (It is also where most gems are hosted)

Just navigate over to http://rubyforge.org to get started

If you want to find a project, you have a few options. First is the
search box located at the top right of the website.

Second is the project tree where you can find projects by the category
they are in.

Third is the most popular projects on the homepage, which can be
helpful from time to time.

If you find a project that you like, you can download it, or install
it as a gem if it is available. Both of which will be covered a little
later in this tutorial.

Finding Projects – GitHub

Github is another project hosting site, that easily lets developers
collaborate using the version control system, git. Github has been
gaining a lot of popularity with Ruby programmers lately and you can
find many Ruby projects here.

GitHub is located at http://github.com

GitHub has search functionality, and most popular like Rubyforge, but
it is a little more comprehensive.

GitHub also offers nice graphs and many download options depending on
your needs.

Using Rubygems

To start using rubygems, first you have to install it. If you
installed via a one-click installer you probably already have it. To
check if you have it installed, open your command prompt and enter
“gem”. If nothing comes up, it is not installed.

If you are on Debian or a variant of it (such as Ubuntu) this command
will get you rubygems: sudo apt-get install rubygems

Otherwise go to http://rubygems.org/ and download rubygems from there.

After you’ve installed, run the command:
gem

to make sure the installation succeed. If not you may have to add
rubygems to your PATH, a quick Google search will tell you how.

For this example I you will install the gem hpricot, which parses HTML.
simply use the command:
gem install hpricot
or
sudo gem install hpricot

It should install successfully, and now you can start using it in your code!

But before we do that, I would like to show you a few more features or rubygems.

“gem list” lists all the gems you have installed
“gem uninstall gem” uninstalls the specified gem
“gem update” updates all your gems
“gem help commands” shows all commands that rubygems has, so you can
explore on your own!

Using the code

Now that you have installed a gem, or downloaded a projects source
code, you can use it in your own programs.

To obtain access to an installed gem, or the source file add the
following line to the top of your program:

require 'rubygems'
require 'name' # Name can be a gem or a source file

if you are just using a source file, you don’t need to require rubygems
example:

require 'rubygems'
require 'hpricot'

If you are loading a file that can change, use load:
load ‘name’ # Name can be a gem or a source file

Note that I said source file. This means that you can separate your
own code into different files and load them in using the load or
require methods!

Now we have reached that sad sad time, when the episode starts ending.

If you have any question, comments, or suggestions leave a comment on
this page, or send me an email at tyler@manwithcode.com

Please do not forget to donate, a small $5 or $10 donation will help
more than you realize!

Thanks for watching, Goodbye.

• Variable Scope
• Class creation
• Open Classes
• Class Inheritance
• Modules

Transcript:

Hello Everybody and welcome to Programming With Ruby Episode 10,
Objects and Modules. As always, I’m Tyler and this video is brought to
you by manwithcode.com

Variable scope will be explained.

In this episode I will be going over class creation, I touched on this
before but that was a while ago and I will also be going more in-depth

I will be teaching you what class inheritance is.

You will also find out what open classes are, and why they are useful.

You will learn what modules are, and how and when you should use them

Lets get started!

Variable Scope

I taught you about variables earlier, but I need to go a little more
in-depth for you to be able to write real applications, and not be
confused by some mysterious errors.

What is a variable scope? a variable scope is where the variable is
available for use in the program. The code in classes and methods that
you define have a different scope than the code outside
them. Different scopes are introduced when classes and methods are
defined.

There are 5 different types of variables:
1. local variable ex: variable
2. instance variable ex: @variable
3. class variable ex: @@variable
4. global variable ex: $variable
5. constant variables ex: VARIABLE

A local variable is available in the scope in which it is defined. An
instance variable is available in the instance of the class it was
defined. A class variable is available from any instances of that
class. A global variable is available anywhere. A constant is
available anywhere, but can only be changed within the scope it was
defined.

Class Creation

As mentioned in episode 4 you define classes like this, don’t forget
that classes must start with an upper case letter:

class MyClass
end

and create them like this:

variable = MyClass.new

You can define methods inside the class:

class MyClass
    def hello
        puts 'Hello!'
    end
end

If you define a method named ‘initialize’, that method is run when the
class is instantiated. This is very useful in many situations, like
creating a screen in a game or connecting to the database in a web
application. This is also the usual place for defining instance variables

class MyClass
    def initialize
        @database = connect_to_database
    end
end

A method defined with ‘self.’ in front of it’s name is called a class
method, because the method is available outside of the class, and you
don’t have to instantiate an object. These can be useful for times
when you don’t want create objects, or want certain information about
all the instances of a class.

class MyClass
    def self.game_objects
        # Return all objects in the game
    end
end

Open Classes

So now that you know more about creating classes, I would like to call
your attention to a very useful feature of Ruby, Open Classes.

The term Open classes means you have the ability to add or substitute
code in a class that is already defined. This is quite easy to do too,
all you have to do is define a class in the same way you always do,
just with a pre-existing class. You only have to define what you are
adding, or overwriting, you don’t have to define the WHOLE class
again.

Take for example, the String class. This class (obviously) is the
class from which all strings are created. Lets say, for example that
you had some code that took a string, and gave back an array that had
each word in it. You could do this:

def words(string)
    string.scan(/\w[\w\'\-]*/)
end
words("Hello World") #=> ["Hello", "World"]

But it looks a lot nicer, and is more object-oriented if you do this instead:

class String
    def words
        scan(/\w[\w\'\-]*/)
    end
end
"Hello World".words #=> ["Hello", "World"]

You can probably see why this can be useful.

Be careful though, if you override existing functionality, you run the
risk of breaking that functionality in your code, and all the external
code your project uses.

Class Inheritance

Lets say you are making a video game. In that game you will have many
different types of enemies.

Now, odds are that all your enemies will have stuff in common. They
probably will all have health, ammo, etc. They all will have to draw
themselves on the screen, animate when they move, etc.

So you can see that with many different types of enemies, you would
have to have lots of duplicate code in each class. This is solved via
class inheritance. Class inheritance allows you to write one class
that contains all the common code. Then when you create other classes
you can specify that those classes will use (inherit) that common
code.

You specify if a class is inheriting from another by following the
class name, with a less than sign followed by the name of the class
you are inheriting from.

You can also re-implement some of that common code, if needed.

For example:

class Enemy
    def draw
        # Drawing Code
    end
end

class Soldier < Enemy
    def move
    end

    def shoot
    end
end

class DifferentEnemy < Enemy
    def draw
        # Changes the draw functionality, only for this class
    end
end

Another thing to keep in mind, if you redefine the initialize method
in your inherited class, you must call the super method.

Modules

Modules are like classes, except they can’t be initialized, and every
method has to be prefixed with “self.” like class methods.

This limitation in functionality may make you wonder when modules are
ever useful. There are actually only a few times. First is to keep
parts of your code separated. The more important second reason is when
you are creating a library of code for others to use. This is so the
functionality in the library isn’t stepping over or redefining classes
you have already defined (if they happen to have the same name).

You define modules just like you do classes, except using the module keyword:

module DataVisualizer
    class Grapher
    end

    class Plotter
    end

    def self.data_compatible?
    end
end

To access methods that modules define you simply do:

module MyModule
    def self.x
    end
end
MyModule.x

To access classes defined by modules, you have to use double colons:

module DataVisualizer
    class Grapher
    end

    class Plotter
    end
end

DataVisualizer::Grapher.new

That’s all there is to know about modules, meaning this is the end of
the episode!

Please donate, those these videos are free, it costs money to make them.

If you have any questions comments or suggestions about anything
related to Man With Code or the Ruby tutorials, you can leave a
comment on this page or email me at tyler@manwithcode.com

Than you very much for watching, goodbye!

Part 2:

Covered in this episode:

• Code Blocks
• if, else, unless
• case, when
• while, until, for loops

Transcript:

Hello everybody and welcome to Programming With Ruby Episode 9, Flow
Control. I’m Tyler and this video is brought to you by manwithcode.com

So far all of the programs and code that I have shown you has been
completely linear. There has been no way to loop based on a condition
or do something based on what the user inputs.

In this episode I will be showing you how to do all this, and I will
also be explaining to you what a code block is, since I’ve been
mentioning them in almost every episode previous to this.

This episode is REALLY LONG! Feel free to pause the video and think
about what’s been said or try out code yourself.

Code Blocks

Throughout the previous videos, I’ve been telling you about code
blocks, I’ve also been telling you I’ll teach you what they are in a
later episode. That episode has finally come.

Code blocks look something like this:

my_array.each do |item|
    puts item
end

or like this:

my_array.each { |item| puts item }

Both of those actually do the same thing! The .each method takes a
block as an argument. The block is what is between the do and end
keywords, or the curly braces, depending on which format you use.

The item between the pipe characters (which is above the ENTER key) is
the variable the .each method gives you (in this case the item in the
array).

The rest of the code block is just normal Ruby code. Not so complicated, eh?

(Keep in mind that there are more metheds besides .each that take code blocks)

If, Else, and Unless

A basic if statement would look like this:

x = 3
if x < 5
    # Do something
end

The “x < 5″ is the condition that has to be true for the code to
run. If that condition is true, the code between the “if” and “end”
keywords is run.

There are many different conditional operators you can use:

==
<
>
<=
>=
!=

Just be sure to keep in mind that the “is equal” operator uses two
equal signs, not one.

If you would like code that is run when the condition is false:

x = 3
if x < 5
    # Do something if true
else
    # Do something if false
end

In a similar way you can execute code if the first condition is false
but a second is true:

x = 3
if x < 5
    # Do something if true
elsif x == 3
    # Do something if the first is false and this is true
else
    # Do something in all are false
end

In a different way you can only execute the code if two conditions are true:

x = 3
y = 2
if x == 3 and y == 2
    # Do something
end

You can also only execute code if one of any conditions are true:

x = 3
y = 4
if x == 3 or y == 2
    # Do something
end

There is also the evil twin brother of if, unless:

x = 3
unless x == 3
    # if x is 3, this code will not run
end

You can chain all of these together in almost any way you choose.

Case, When

Another way to evaluate conditions is using case, when:

x = 3
case x
    when 1 then
        # do something
    when 3 then
        # do something
    else
        # do something if none are true
end

You can’t do many complex conditionals, but it can be nicer than a
long chain of if, else’s

while, until, and for loops

Similarly to the above if statements, while, until, and for loops will
execute code based on a condition, but they will do it multiple times.

while:

x = 1
while x < 5
    x += 1
    puts x
end

Similar to the relationship between if, and unless. while has an evil
sister, until

x = 1
until x > 5
    x += 1
    puts x
end

There are also for loops, which allow you to iterate over something

foods = ["ham", "eggs", "cheese"]
for food in foods
    puts food += " is yummy!"
end

There is also .each, for’s evil stepchild:

foods = ["ham&", "eggs", "cheese"]
foods.each do |food|
    puts food += " is yummy!"
end

Concrete Example

A menu system

input = ""
until input == 'quit'
    puts "
Menu
(1) Hi!
(2) Credits
(3 or quit) Exit
"
    input = gets.chomp!
    case input
        when "1" then
            puts "Hi!"
        when "2" then
            puts "Written By: Tyler"
        when "3" then
            input = 'quit'
        else
            puts "Invalid input"
    end
end

Lets break it down.

First we set the input variable to an empty string (so the second line
dosen’t give us an error)

Then we use an until loop that quits when input is equal to ‘quit’

Next we print the menu (which is unindented so it doesn’t print to the
screen indented)

After that we get input from the user, use .chomp! to remove the
newline character created from pressing ENTER, and put the input into
the input variable

Then we have a case statement, when “1″ we print “Hi!”, when “2″ we
print who it was created by, when “3″ we quit, otherwise we print out
“Invalid input” to tell the user they entered something wrong.

This brings us to the end of the video.

If you like these videos please donate, because I’m doing this all for free

If you have any questions, comments, or suggestions, you can leave a
comment on this page. Or you can email me at tyler@manwithcode.com

I covered a lot of material in this episode and I urge you to watch it
again, go to the original post and look at the code (link is in the
description) and write some code yourself.

Thank you very much for watching, goodbye!

Covered In This Episode:

• What are Hashes?
• Hash Creation
• Hash Accessing
• Hash iteration
• Hash Methods

Transcript:

Hello Everybody and welcome to Programming With Ruby Episode 8,
Hashes. I’m Tyler,and this video is brought to you by, manwithcode.com

In this episode I will be telling you what hashes are, how you can
create them, access them, and iterate over them. Finally at the end I
will show you some useful methods that hashes have.

What Are Hashes?

Hashes are like arrays, which you learned about in the previous
episode. Except that they have no order, and instead of being accessed
by an index number, they are accessed by what is called a key (which
can be anything). That key points to a value, which is the actual data
inside the hash

Arrays are used for lists of data, where hashes are used to relate
data. I may have a hash where the keys are my friend’s names, and the
values are their birthdays.

Hash Creation

Similarly to how arrays are created with square brackets, hashes are
created with curly brackets:

my_hash = {}

Items are defined like this:

birthdays = {"Amy" => "May", "Dakota" => "January"}

Each key-value pair are separated by a comma, and their relation is
defined with =>

Accessing Hashes

You can access hashes in almost the same way you access arrays, except
by using the key value, instead of an index number:

brithdays["Amy"] #=> May

You can define new keys and values:

birthdays["Zack"] = "April"

Iterating Over Hashes

Hashes have an each method like arrays do:

my_hash = {"cat" => "hat", "dog" => "log"}
my_hash.each do |pair|
	puts "Key: " + pair[0]
	puts "Value: " + pair[1]
end
#=> Key: cat
#=> Value: hat
#=> Key: dog
#=> Value: log

They also have each_key and each_value which let you iterate over each
key or value in a similar way.

Useful Hash Methods

delete(key) deletes a key-value pair
empty? True or False if the hash is empty
keys returns the keys
values returns the values
size how many key-value pairs there are

That wraps it up for this episode!

Please donate, or I will stop making these videos. There should be a
link to donate to the right of this video.

If you have any questions or comments leave a comment on this page or
email me at tyler@manwithcode.com

Thanks for watching, goodbye!

Covered In This Episode:

• What Aarrays Are
• Array Creation
• Accessing Arrays
• Array Iteration
• Other Array Methods

Transcript:

Hello everybody and welcome to Programming With Ruby Episode 7,
Arrays. I’m Tyler. And this video is brought to you by manwithcode.com

In this episode I will be telling you what arrays are, how you can
create an array in ruby. How to manipulate arrays by accessing them,
iterating over them, and by showing you a few useful methods they
have.

Lets get started!

What are Arrays?

Arrays are a type of variable. Think of an array as a list. This list
can hold anything, names, numbers, objects, anything. Objects in the
array have a number, depending on what place they are in the
list.

Because computers start counting at 0, the first element in the
array is 0, instead of one.

Array Creation

This is how a variable is defined in ruby:

x = []

This is an empty array, if we wanted an array with something in it:

todo_list = ["Cut Grass", "Buy Food", "Fix Tom's Computer"]

Each bracket represents the start and the end of the array,
respectively. Each item in an array is separated by a comma.

Accessing Arrays

Now that you have created an array, how do you go about accessing each
item?

I told you earlier that each item had a number, so to access the first
item in the array you would do:

todo_list[0] #=> "Cut Grass"

You can also add items to an array in a similar way

todo_list[3] = "Go Skydiving"

Another way to add items is to use +=, which you may recognize from
previous tutorials

todo_list += ["Eat Sandwich"]

Don’t forget that if you use += that the item your adding has to be
between brackets

You can also use ranges to access elements in the array. ranges are
used in a similar way that you normally access arrays, except ranges
look like this:

todo_list[0..2] #=> ["Cut Grass", "Buy Food", "Fix Tom's Computer"]

The 0 is the start number and the 2 is the end number. you can also
use -1, which is the end of the array:

todo_list[3..-1] #=> ["Go Skydiving", "Eat Sandwich"]

Array Iteration

If you want to loop over each element of an array you use the each
method:

numbers = [1, 2, 3, 4]
numbers.each do |number|
puts number * 2
end
#=> 2 4 6 8

You can do the same thing, but turn the output into an array with the
collect method:

numbers = [1, 2, 3, 4]
numbers.each do |number|
number * 2
end
#=> [2,4,6,8]

Other Array Methods

Now I’m going to show you some useful methods arrays have!

empty? tells you if an array is empty
sort sorts the array (alphabetically)
reverse reverses the array
delete deletes a specified item from the array
delete_at deletes whatever is at that index in the array
find finds an item with the specified value
inspect returns the way an array looks in code, instead of its values, this is useful for puts my_array.inspect
length how long the array is

That’s it for today’s episode

Please don’t forget to donate, the link should be to the right of this video

If you have any questions or comments, leave a comment on this page or
email me at tyler@manwithcode.com

Thanks for watching, bye!

Covered in this episode:

• String Literals
• String Expressions
• String Methods
• Regular Expressions
• Getting User Input (gets)

Transcript:

Hello Everyone and Welcome to Programming With Ruby Episode 6,
Strings. I’m Tyler, your presenter. This is brought to you by
manwithcode.com

In this episode I will be telling you what string literals are. I will
show you expressions you can use with strings, which are similar but
still different than expressions with numbers. I will show you useful
methods strings have. I will show you how to use regular
expressions. Finally I will teach you how to get input from the
user.

On to the Code!

String Literals

According to wikipedia, string literals are the representation of a
string value within the source code of a computer program. For
example:

puts "Hello World" # Hello World is the string literal

String Expressons

The only string expressions are the plus and multiplication sign. The
plus sign connects strings together, the multiplication sign repeats a
string a certain number of times.
Let me show you how it works:

"Hello " + "World!" #=> "Hello World!"
"Hello " * 3 #=> "Hello Hello Hello"

String Methods

Here are some useful String methods:
empty? tells you if you are dealing with an empty string
length tells you how long a string is
each_char lets you iterate over each character
capitalize capitalizes the first character
upcase makes all characters upper case
downcase makes all characters lower case

Regular Expressions

Regular expressions are a way to match elements in other strings. It
is easier to show you than to describe to you, so here we go!

The simplest is substitution:

"Hello World".sub("Hello", "Goodbye")
#=> "Goodbye World"

But if you have more than one hello:

"Hello Hello Hello".sub("Hello", "Goodbye")
#=> "Goodbye Hello Hello"

This happens because the sub method only replaces the first occurrence
of “Hello”. The gsub method fixes this:

"Hello Hello Hello".gsub("Hello", "Goodbye")
#=> "Goodbye Goodbye Goodbye"

What if you want to manipulate parts of a string using regular
expressions. The scan method is what you want!

# /n means new line
"Who are you".scan(/../) { |x| puts x }
#=> Wh\no \nar\ne \nyo
# With no whitespace:
"Who are you".scan(/\w\w/) { |x| puts x }
#=> Wh/nar/nyo

Regular Expressions are a vast topic that I can’t completely cover
here, so do a Google search to find out more.

Getting User Input

You can get user input with the “gets” method:

a = gets
# The user inputs: I like pie
puts a #=> "I like pie"

That wraps it up for todays episode.

Don’t forget to donate, the link is to the right of this video

If you have any questions or comments, leave a comment on this page or
email me at tyler@manwithcode.com

Bye!