How to Install Ruby

The time has come for you to begin writing simple programs. Before you can do that, you need to install Ruby. This is explained in Appendix B at the back of the book.

How to Save Programs

The next thing to learn is how to save your work. When writing a computer program (informally called code), it is often important to be able to save it as a plain text file, which can be opened and used later.

To save a program, you must first open a piece of software that allows you to create, save, and edit text files. These programs are called text editors, and examples include Notepad, Scite (included in the one-click installation of Ruby), and many others we discuss in Appendix C. For more advanced editors, you may want to look into vim and emacs. There is also a version of the integrated development environment (IDE) Eclipse that works with Ruby. Eclipse includes a plain text editor. Once a text editor is open, be sure it is set to save as an unformatted text file (FileName.txt). Most word processors, such as Word, add special characters for document formatting, so these should not be used for writing programs. If special characters are turned off by saving the document as a plain text file (.txt), you can use various word processing programs, such as Word.

Now you are ready to write and save programs.

Constants: Variables That Never Change

If a variable does not change, it is called a constant. For example, 3.14159 is commonly understood as π or simply pi. By creating a variable called PI and never changing it, that is, making the variable into a constant, one can use PI throughout the program instead of repeatedly typing the numeral string. By following this convention, fewer errors are likely to occur as this value is only entered one time, namely when the constant value is assigned. Typing the value of π multiple times might lead to typing errors. Furthermore, readability is enhanced. For example, it is far more intuitive to describe an algorithm that computes the area of a circle as one that squares the radius and multiplies the result by PI than one that squares the radius and multiplies by 3.14159. As noted before, constant names start with a capital letter, and by convention are all uppercase.

Data Types

Data types indicate the nature of the variable and the range of valid values for that variable. Data types also indicate how much memory to allocate for each type of data. It is important to know that specific types of data have specific sizes in memory. As will be evident later, data types also define the meanings of allowed operators.

Ruby refers to data types as classes. In Ruby, as in other object-oriented languages, a class is a description of objects. A detailed discussion of objects takes place in Chapter 9. For now, the relevant Ruby classes are Fixnum, Bignum, Float, Boolean, and String.

Integer

An integer is defined as any natural number (0, 1, 2, . . . ) or its negative (0, -1, -2, . . . ). The integer data type is simply a subset of the infinite mathematical integers. In a 32-bit system, integers range in value from -2,147,483,648 to 2,147,483,647. Note that if the number of bits used differs, so will the range.

Consider the following:

irb(main):01:0> x = 5
=> 5

When we type in x = 5, we are doing two things. First, we are creating a variable x that stores an integer of the class Fixnum. Second, we are assigning the value of 5 to x. In some languages, variables must be explicitly assigned to a type before they are used. In Ruby, the class of the variable is either explicitly stated or inferred in every assignment of the variable. In this case, Ruby infers the Fixnum class.

Imagine creating a huge number, out of the range of supported integers:

irb(main):02:0> x = 1_000_000_000_000_000
=> 1000000000000000

The Bignum class is used by Ruby for very large integers not contained within the previously stated integer range. This class enables the creation of integers outside the range of those possible in Fixnum.

Float

Simply put, a float is a decimal number. In Ruby, floats can be defined either with numbers containing a decimal place or in scientific notation.

irb(main):001:0> x = 5.0
=> 5.0
irb(main):002:0> x = -3.14159
=> -3.14159
irb(main):003:0> x = 3.5e2
=> 350.0

Similar to the integers example, when we execute x = 3.14159, we create a variable x that stores a float. We then assign the value of 3.14159 to x. Negative values are expressed with a leading negative sign (-).

For scientific notation, values are expressed in powers of 10 following the symbol e. Hence, 3.5e2 indicates 3.5 × 10² = 350. Very small numbers can be represented as negative powers of 10. You may find that the designation real is used in other languages to denote float.

Strings

Strings are simply one or more characters surrounded by quotes. Both double quotes (") and single quotes (') can be used, but if you need to use a single quote inside your string, you must bound your string with double quotes (e.g., “The computer said, ‘Hello World!’ ”).

irb(main):001:0> x = "hello world"
=> hello world
irb(main):002:0> y = "hello, 'world'"
=> hello, 'world'

To store characters (such as letters and symbols), a character encoding scheme, as discussed in Chapter 2, is used. For example, to encode the English alphabet, we need to represent 26 uppercase letters, 26 lowercase letters, and a variety of special characters. Using eight bits (one byte) per character allows us to encode 256 characters, a number more than sufficient to represent English. Each character is assigned a unique number from 0 to 255.

Booleans

Booleans can hold only two different values: true and false. They are sometimes referred to as flags.

irb(main):001:0> x = true
=> true
irb(main):002:0> y = false
=> false

Output Using Variables

Displaying text in Ruby is simple. Try entering the following at the command prompt:

irb(main):001:0> puts "Hello World"

The puts method (short for outPUT a String) simply displays a string on the screen. Notice the string is contained in quotation marks; otherwise, both Hello and World would be interpreted as variables. Variables are displayed on the screen using similar syntax, except without quotation marks:

irb(main):002:0> text = "Hello World"
=> "Hello World"
irb(main):003:0> puts text
=> Hello World

This example stores the string “Hello World” in a variable named text and then displays the value stored in the text variable using the puts method. This method is not limited to strings and can be used with other classes including integers, floats, and Booleans.

The use of classes to define data types means a variety of methods can be done for each type. For example, x.length indicates the size of a string when x is defined as a string.

Display User Input

Displaying user input in Ruby is almost as easy as displaying output. Try entering the following in the command prompt:

irb(main):001:0> age_input = gets

The gets method (short for GET a String from the user) stops the program and waits for the user to type some text and then press Enter. The text typed by the user will be stored as a string in a variable called age_input. Due to the nature of the gets method, the value stored in age_input will be a string, but you need an integer if you wish to mathematically manipulate it. We create another variable age and set it equal to the integer value of the user’s input by converting the string age_input to an integer. This is done by issuing the following command:

irb(main):002:0> age = age_input.to_i

The method to_i converts age_input to an integer.

Basic Programs

Now that you have learned how to display text and request user input, you can develop a program that calculates the area of a rectangle. Try using the problem-solving approach discussed in Chapter 1 to create this program.

Step 1: Understanding the Problem

Ask yourself key questions that must be answered to properly design the program:

• How do you find the area of a rectangle?

• How many variables do you need to represent that area?

• What data type do the variables need to be?

Step 2: Write Out the Problem in Plain Language

Before writing out the problem, remember that the input method stores user input as strings, so we need to convert the lengths (which are stored as strings) to integers before performing mathematical operations with them.

1. Ask for the length.

2. Store the length.

3. Ask for the width.

4. Store the width.

5. Convert the length to an integer.

6. Convert the width to an integer.

7. Calculate rectangle area (area = length × width).

8. Display area.

The equation for the area of a rectangle is the product of its length and width. Although it does not affect this equation, remember that the rules for order of operations apply in Ruby. To change the order of operations, use parentheses.

Step 3: Rewrite the Plain Language into Code

See Example 3-1. In the figure, as with all other program illustrations, the line numbers are not part of the code; they are added strictly for explanatory purposes. In line 8, we are printing an integer represented in the variable area. This differs from the printing of character strings in lines 1 and 3. Ruby automatically determines the data type, if it can. This is called dynamic or “duck” typing. This functionality is helpful; however, as you will see, automatic type determination can introduce problems. In this example, though, it helps in that puts area is mapped to puts area.to_s. Note that generally speaking, the .to_* method is a type conversion operation where the target type is represented by the * (a wildcard). For example, you have now seen conversion to integer (to_i) and to string (to_s).

    1 puts "What is the length?"	# Ask for the length 
    2 length_input = gets		# Stores the length 
    3 puts "What is the width?"	# Ask for the width 
    4 width_input = gets		# Stores the width 
    5 length  = length_input.to_i	# Convert length to integer 
    6 width = width_input.to_i	# Convert width to integer 
    7 area = length * width		# Calculate rectangle area 
    8 puts area			# Display area 

Step 4: Test the Code in the Computer

Similarly those who are adventurous can type the code lines from step 3 into a file and run the code from there. For those who are unsure, no worries; we address files later on. For now, simply see if you get the desired results; if not, make sure you typed everything correctly.

If it works, congratulations! You have just created a program that calculates the area of a rectangle.

Syntax Errors

As a programmer, it is important for you to become comfortable with error messages. Even the most experienced computer programmers will have a typo or forget a quotation mark regularly. When you first start, error messages will seem incomprehensible. Later, they will help you fix the problem quickly.

Try the following command in irb:

irb(main):001:0> x = 1 + "hello"
TypeError: String can't be coerced into Fixnum
     from (irb):1:in '+'
     from (irb):1

Syntax errors refer to code that Ruby cannot actually execute. Since it does not make sense for Ruby to add an integer to a string, it stops execution and informs you of the location where it had to stop.

Let’s move on to a more realistic example. When entering strings, we are likely to forget quotes once in a while.

irb(main):002:0> x = hello
NameError: undefined local variable or method 'hello' for
main:Object
from (irb):2

Wait! Why does the Ruby interpreter not just tell us that we forgot quotes? Ruby must guess what we intended. All Ruby knows is that we tried assigning hello to x. Since any string not contained in quotes is the name of a variable or a command, Ruby tries to find the value stored in a variable named hello. Since Ruby cannot find any variable named hello, it prints an error. It is important to start viewing code in terms of how Ruby might interpret it, but this is a skill that will take time to develop. Meanwhile, realize that errors will happen, and expect to be learning from them.

Logic Errors

Errors that Ruby cannot catch are logic errors. They are problems with a program that cause it to return the wrong or undesired result. For example, if you are trying to find the area of a rectangle, but you multiplied the height by itself instead of by the width, that would be a logic error.

The Ruby interpreter, the program that executes the Ruby instructions input by the user, does not try to guess that we meant to use a different variable. Logic errors are often much harder to trace than syntax errors because of this. To avoid them, it is often useful to look at your program and “play computer.” That is, pretend that you are the Ruby interpreter, and follow the steps that will be implemented as the program is executed. From this point on, we’ll use the words Ruby and Ruby interpreter interchangeably.

A more common error involves integer division. Arithmetic expressions that operate on integers will always evaluate to integer form. This happens even with division, where the result would otherwise be a decimal. Ruby does this by truncating the arithmetic result (chopping off the decimal place and all the digits to the right of it). For example, 5 divided by 2 will evaluate to 2 instead of to 2.5.

irb(main):003:0> 5 / 2
=> 2

If you get a wrong value using this computation in a program, then your final result will likely be erroneous, too.

3.8.1 Key Concepts

• Ruby programs can be created/edited in any text editor (as defined previously), so long as the editor can save files as plain text. It is highly recommended that you use an editor suited for writing programs.

• When naming variables, it is a common practice to separate each word in a variable name with an underscore (_).

• Programming languages use various data types to perform various operations. Ruby uses many data types, including integer (Fixnum and Bignum), float, string, and Boolean.

• It is important to understand the syntax behind simple mathematical operators. Mathematical operators will often be used when programming. Pay attention to the order of operation.

• To output information onto the screen, use the puts command. To input information from the user, use the gets command.

• The three types of programming errors are syntax errors, logic errors, and type errors. Type errors often arise from mixing data types that cannot be mixed, such as integers and strings.

• Conversion errors are a subset of type errors.

3.8.2 Key Definitions

• Variable: A piece of data attached to a name, class, and memory location.

• Instantiate: In this simple initial presentation, creating a variable. See Chapter 9 for more information.

• Constant: A variable that is set once and never changed.

• Initialize: To assign a value to a variable when the variable is created.

• Data class: Information about the variable that defines the possible values a variable can have and what operations can be performed using it. A more complete description is presented in Chapter 8.

• Integer: A class that defines a whole number. Ruby recognizes two classes:

  • Fixnum: An integer with a limited range. In 32-bit systems, the range –2,147,483,648 to 2,147,483,647.

  • Bignum: An integer outside the range of Fixnum.

• Float: A class that defines a decimal number.

• String: A class that defines a sequence of characters.

• Boolean: A class that defines a value of either true or false.

• Syntax errors: Errors produced by incorrect syntax for the programming language.

• Logic errors: Errors produced by bad logic.

• Type errors: Errors produced by mixing data types that cannot be mixed.