Ruby Programming

Welcome! After previewing the two Ruby programs we'll write in this course, we help you get your development environment set up so you can start writing Ruby code.

No time to waste—let's run some Ruby code! We look at two ways: interactively using IRB and by writing Ruby program files. You'll use both throughout this course and in your day-to-day Ruby programming.

We gotta start somewhere, and every Ruby program has its fair share of strings and numbers. We get our program started with style by printing some text to the screen, using variables, and formatting strings.

Pretty much everything in Ruby is an object. So we need to know how to create them, manipulate them, and get them to do things. You'll learn object-oriented programming the Ruby way!

Lurking in the shadows, Ruby has a special object named self. It's a bit mysterious at first, but we demystify self so you can use it with confidence.

The easiest way to make code reusable is to put it in a Ruby method. We learn how to define methods and call them with both positional and keyword arguments.

Ruby comes with a core set of built-in classes. But to write good object-oriented programs, we need to define our own classes representing the key concepts in our program.

You often want to be able to read and/or write the internal state of an object, externally. That's where Ruby attributes come in. When should you use them and how do they work? We answer that.

Symbols, aiiieeeee! They seem so simple, and yet it's tempting to overthink them at first. After seeing a few examples, you'll totally get symbols.

If this, then that, otherwise something else. Depending on whether or not certain conditions are met, programs take different paths. We explore several ways to express conditionals in Ruby.

Ain't no party like an array party. You often need to put objects in a collection—a list of names, favorite movies, or game players—and then interact with them as a group. Ruby arrays are themselves objects with methods, and they're used everywhere!

At this point, we know how to create objects and work with them in isolation. But object-oriented programming is all about different kinds of objects working together. So we define our second Ruby class and design it to collaborate with our first class.

The object referenced by the variable named self automatically changes depending on where we are in a program. How does that work and why is it important? We show you.

Ruby has common-sense conventions for organizing code into files and directories. This makes it easier to find, reuse, test, and distribute our code.

Up to this point, we've written a fair amount of Ruby code. How do we know it works? Currently we have to visually inspect the output. That's tedious and error-prone, so it's time to write automated tests that verify our code always works as expected.

Everywhere you look in Ruby, you'll see blocks. Get really good with blocks, and you've got the gist of Ruby. We start with the basics of blocks and then explore more uses of blocks in future sections.

Sometimes you just need an object that represents values. In those situations, reach for Ruby's Struct or Data class. We show you when and how to use both.

Modules have special powers, so to speak, that are often untapped by beginners. In this section we introduce modules as a way to group together related constants and methods that don't belong in any particular class.

Second to arrays, hashes are the other Ruby collection type you'll use most often. A hash is a collection of key-value pairs. Given a key, you can look up its value. And similar to arrays, hashes have a variety of convenient methods.

Once you learn how to use the methods in Ruby's built-in Enumerable module, your code will become more concise and expressive. We explore the most common Enumerable methods in detail, and put them to good use in our program.

No program is an island. It needs to interface with the outside world. And Ruby has elegant ways to read input and write output. We start by creating an interactive command-line interface to our program.

Moving on to file I/O, we learn how to read data from a file and write the program's results to another file. Along the way, we explore the File class which has a bunch of useful methods for working with files and directories.

While refactoring our code, we discover an opportunity to define a class-level method and compare it to instance methods.

Errors happen. Files go missing. Data is invalid. Network connections fail. And sometimes we just plain mess up. In this section we learn how to handle errors (exceptions) gracefully.

One way to share code between classes is to use inheritance. We extend our program to include several new, specialized types to see examples of inheritance in action.

Another, arguably better, way to share code between classes in Ruby is to use mixins. This is where modules reveal their true power. We refactor our program to mix a common set of capabilities into several classes.

Good Ruby citizens don't pollute the global namespace. So to avoid naming clashes, we use modules to put all our code in a unique and tidy namespace.

For the grand finale, we package up all the code and distribute it as a RubyGem. You learn how to write a GemSpec, build a RubyGem, and publish it to a public server.