Exercise 41: Learning To Speak Object Oriented

In this exercise I'm going to teach you how to speak "object oriented." What I'll do is give you a small set of words with definitions you need to know. Then I'll give you a set of sentences with holes in them that you'll have to understand. Finally, I'm going to give you a large set of exercises that you have to complete to make these sentences solid in your vocabulary.

Word Drills

class
Tell Ruby to make a new type of thing.
object
Two meanings: the most basic type of thing, and any instance of some thing.
instance
What you get when you tell Ruby to create a class.
def
How you define a function inside a class.
@
Inside the functions in a class, self is a variable for the instance/object being accessed.
inheritance
The concept that one class can inherit traits from another class, much like you and your parents.
composition
The concept that a class can be composed of other classes as parts, much like how a car has wheels.
attribute
A property classes have that are from composition and are usually variables.
is-a
A phrase to say that something inherits from another, as in a "salmon" is-a "fish."
has-a
A phrase to say that something is composed of other things or has a trait, as in "a salmon has-a mouth."

Take some time to make flash cards for these terms and memorize them. As usual this won't make too much sense until after you are finished with this exercise, but you need to know the base words first.

Phrase Drills

Next I have a list of Ruby code snippets on the left, and the English sentences for them:

class X(Y)
"Make a class named X that is-a Y."
class X(object): def initialize(J)
"class X has-a initialize that takes a J parameter."
class X(object): def M(self, J)
"class X has-a function named M that takes a J parameter."
foo = X()
"Set foo to an instance of class X."
foo.M(J)
"From foo get the M function, and call it with parameter J."
foo.K = Q
"From foo get the K attribute and set it to Q."

In each of these where you see X, Y, M, J, K, Q, and foo you can treat those like blank spots. For example, I can also write these sentences as follows:

  1. "Make a class named ??? that is-a Y."
  2. "class ??? has-a initialize that takes ??? parameters."
  3. "class ??? has-a function named ??? that takes ??? parameters."
  4. "Set foo to an instance of class ???."
  5. "From foo get the ??? function, and call it with parameters ???."
  6. "From foo get the ??? attribute and set it to ???."

Again, write these on some flash cards and drill them. Put the Ruby code snippet on the front and the sentence on the back. You have to be able to say the sentence exactly the same every time whenever you see that form. Not sort of the same, but exactly the same.

Combined Drills

The final preparation for you is to combine the words drills with the phrase drills. What I want you to do for this drill is this:

  1. Take a phrase card and drill it.
  2. Flip it over and read the sentence, and for each word in the sentence that is in your words drills, get that card.
  3. Drill those words for that sentence.
  4. Keep going until you are bored, then take a break and do it again.

A Reading Test

I now have a little Ruby hack script that will drill you on these words you know in an infinite manner. This is a simple script you should be able to figure out, and the only thing it does is use a library called urllib to download a list of words I have. Here's the script, which you should enter into oop_test.rb to work with it:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
require 'open-uri'

WORD_URL = "http://learncodethehardway.org/words.txt"
WORDS = []

PHRASES = {
  "class ### < ###\nend" =>
       "Make a class named ### that is-a ###.",
  "class ###\n\tdef initialize(@@@)\n\tend\nend" =>
       "class ### has-a initialize that takes @@@ parameters.",
  "class ###\n\tdef ***(@@@)\n\tend\nend" =>
       "class ### has-a function named *** that takes @@@ parameters.",
  "*** = ###.new()" =>
       "Set *** to an instance of class ###.",
  "***.***(@@@)" =>
       "From *** get the *** function, and call it with parameters @@@.",
  "***.*** = '***'" =>
       "From *** get the *** attribute and set it to '***'."
}

PHRASE_FIRST = ARGV[0] == "english"

open(WORD_URL) {|f|
  f.each_line {|word| WORDS.push(word.chomp)}
}

def craft_names(rand_words, snippet, pattern, caps=false)
  names = snippet.scan(pattern).map do
    word = rand_words.pop()
    caps ? word.capitalize : word
  end

  return names * 2
end

def craft_params(rand_words, snippet, pattern)
  names = (0...snippet.scan(pattern).length).map do
    param_count = rand(3) + 1
    params = (0...param_count).map {|x| rand_words.pop() }
    params.join(', ')
  end

  return names * 2
end

def convert(snippet, phrase)
  rand_words = WORDS.sort_by {rand}
  class_names = craft_names(rand_words, snippet, /###/, caps=true)
  other_names = craft_names(rand_words, snippet, /\*\*\*/)
  param_names = craft_params(rand_words, snippet, /@@@/)

  results = []

  [snippet, phrase].each do |sentence|
    # fake class names, also copies sentence
    result = sentence.gsub(/###/) {|x| class_names.pop }

    # fake other names
    result.gsub!(/\*\*\*/) {|x| other_names.pop }

    # fake parameter lists
    result.gsub!(/@@@/) {|x| param_names.pop }

    results.push(result)
  end

  return results
end

# keep going until they hit CTRL-D
loop do
  snippets = PHRASES.keys().sort_by {rand}

  for snippet in snippets
    phrase = PHRASES[snippet]
    question, answer = convert(snippet, phrase)

    if PHRASE_FIRST
      question, answer = answer, question
    end

    print question, "\n\n> "

    exit(0) unless $stdin.gets

    puts "\nANSWER:  %s\n\n" % answer
  end
end

Run this script and try to translate the "object-oriented phrases" into English translations. You should see that the PHRASES dict has both forms and you just have to enter the correct one.

Practice English to Code

Next you should run the script with the "english" option so that you drill the inverse operation:

$ ruby oop_test.rb english

Remember that these phrases are using nonsense words. Part of learning to read code well is to stop placing so much meaning on the names used for variables and classes. Too often people will read a word like "Cork" and suddenly get derailed because that word will confuse them about the meaning. In the above example, "Cork" is just an arbitrary name chosen for a class. Don't place any other meaning on it, and instead treat it like the patterns I've given you.

Reading More Code

You are now to go on a new quest to read even more code, to read the phrases you just learned in the code you read. You will look for all the files with classes, and then do the following:

  1. For each class give its name and what other classes it inherits from.
  2. Under that, list every function it has and the parameters they take.
  3. List all of the attributes it uses on self.
  4. For each attribute, give the class it is.

The goal is to go through real code and start learning to "pattern match" the phrases you just learned against how they're used. If you drill this enough you should start to see these patterns shout at you in the code whereas before they just seemed like vague blank spots you didn't know.

Common Student Questions

This script is hard to get running!
By this point you should be able to type this in and get it working. It does have a few little tricks here and there but there's nothing complex about it. Just do all the things you've learned so far to debug scripts. Type each line in, confirm that it's exactly like mine, and research anything you don't know online.
It's still too hard!
You can do this. Take it very slow, character by character if you have to, but type it in exactly and figure out what it does.

Video