Programming Foundations

Question 1

Are variables accessible outside an ‘if condition’?

Answer 1

Yes, they are - since an ‘if condition’ does not create a block.

Variables created inside a block aren’t visible to the outer scope.

Question 2

Where are Kernel methods available in Ruby?

Answer 2

Everywhere. The Kernel module is loaded by ‘Object’, giving us access to all of its methods.

Question 3

Why can we omit the Kernel. in front of method names?

Answer 3

When we write Ruby code that's not in a class, we are working with an object called 'main', which is an instance of 'Object'. The 'Kernel' module is automatically loaded by 'Object
, giving us access to all of its methods.

Question 4

What are some good guidelines on how to write good methods?

Answer 4

• It shouldn’t display something to the output as well as return a value
• Decide whether the method should return something with no side effects OR only perform side effects with no return. The naming should also reflect this.
  ‘

Question 5

What is ‘truthiness’ in Ruby?

Answer 5

Ruby is very liberal about what ‘true’ means.

In Ruby, everything is truthy except nil and false.

Because of this, we don’t have to compare an expression to ‘true’ or ‘false’, and can rely on the expression’s ‘truthiness’ directly.

Example:
if user_input == true

could be just

if user_input

Question 6

What determines variable scoping?

Answer 6

Whether you’re working with blocks (a piece of {..} or do..end following a method invocation.

Example:
3.times do |n|
a = 3
end

Things like loops also have an inner scope. However, they can access outer scope variables and even make changes to them (for example, if you re-assign an outer scope variable in a loop, that change will persist in the outer scope!”

Question 7

Can methods access outer scope variables?

Answer 7

No, they create their own variable scoping that’s entirely out of the execution flow.

The one exception to this is Constants. They tend to behave like global variables and can be accessed by methods and blocks.

Question 8

What is variable shadowing?

Answer 8

Variable shadowing:

We’ve been using the loop do…end, which doesn’t take a parameter, but some blocks do take a parameter. Take for example:

[1, 2, 3].each do |n|
puts n
end

The block is the do…end, and the block parameter is captured between the | symbols. In the above example, the block parameter is n, which represents each element as the each method iterates through the array.

But what if we had a variable named n in the outer scope? We know that the inner scope has access to the outer scope, so we’d essentially have two local variables in the inner scope with the same name. When that happens, it’s called variable shadowing, and it prevents access to the outer scope local variable. See this example:

n = 10

[1, 2, 3].each do |n|
puts n
end
The puts n will use the block parameter n and disregard the outer scoped local variable. Variable shadowing also prevents us from making changes to the outer scoped n:

n = 10

1.times do |n|
n = 11
end

puts n # => 10

You want to avoid variable shadowing, as it’s almost never what you intended to do. Choosing long and descriptive variable names is one simple way to ensure that you don’t run into any of these weird scoping issues. And if you do run into these issues, you’ll have a much better chance of debugging it if you have clear variable names.

Question 9

How do blocks and methods interface with each other?

Answer 9

Technically any method can be called with a block, but the block is only executed if the method is defined in a particular way.

A block is part of the method invocation; essentially the block acts as an argument to the method.

In the same way that a local variable can be passed as an argument to a method at invocation, when a method is called with a block it acts as an argument to that method.

Important to know is that, while methods can not access local variables initialized outside the method scope, blocks CAN do this. They can also reassign those variables!

Key takeaways about methods and blocks :
- The def..end construction in Ruby is method definition

• Referencing a method name, either of an existing method or subsequent to definition, is method invocation
• Method invocation followed by {..} or do..end defines a block; the block is part of the method invocation
• Method definition sets a scope for local variables in terms of parameters and interaction with blocks
• Method invocation uses the scope set by the method definition

Question 10

What does it mean when a method is mutating the caller?

Answer 10

This will affect the original object that is passed in.

Question 11

Is Ruby pass by reference or pass by value?

Answer 11

Some languages make copies of method arguments, and pass those copies to the method — since they are merely copies, the original objects can’t be modified. Objects passed to methods in this way are said to be passed by value, and the language is said to be using a pass by value object passing strategy.

Other languages pass references to the method instead — a reference can be used to modify the original object, provided that object is mutable. Objects passed to methods in this way are said to be passed by reference, and the language is said to be using a pass by reference object passing strategy

Pass by value, as you’ll recall, means copying the original objects, so the original object cannot be modified. Since immutable objects cannot be changed, they act like Ruby passes them around by value. This isn’t a completely accurate interpretation of how Ruby passes immutable objects, but it helps us determine why the following code works like it does

So, is that our final answer to the question of whether ruby is pass by reference or pass by value? It’s neither? Yes. Well, maybe not entirely; there are actually three answers to the question of what object passing strategy ruby uses:

• pass by reference value is probably the most accurate answer, but it’s a hard answer to swallow when learning ruby, and isn’t particularly helpful when trying to decide what will happen if a method modifies an argument – at least not until you fully understand it.
• pass by reference is accurate so long as you account for assignment and immutability.
• Ruby acts like pass by value for immutable objects, pass by reference for mutable objects is a reasonable answer when learning about ruby, so long as you keep in mind that ruby only appears to act like this.

Question 12

How do mutable vs non-mutable objects get passed into Ruby methods?

Answer 12

def increment(a)
  a = a + 1
end

b = 3
puts increment(b)    # prints 4
puts b               # prints 3

Here, the numeric object 3 is immutable. You can reasonably say that b is not modified by #increment since b is passed by value to #increment where it is bound to variable a. Even though a is set to 4 inside the method, and returned to the caller, the original object referenced by b is untouched.

Mutable objects, on the other hand, can always be modified simply by calling one of their mutating methods. They act like Ruby passes them around by reference; it isn’t necessary for a method to modify an object that is passed by reference, only that it can modify the object. As you’ll recall, pass by reference means that only a reference to an object is passed around; the variables used inside a method are bound to the original objects. This means that the method is free to modify those objects. Once again, this isn’t completely accurate, but it is helpful.

Question 13

Is indexed assignment mutating or non-mutating?

Answer 13

It’s mutating.

Indexed assignment, such as that used by String, Hash, and Array objects can be confusing:

str[3] = ‘x’

array[5] = Person.new

hash[:age] = 25

This looks exactly like assignment, which is non-mutating, but is, in fact, mutating. #[] modifies the original object (the String, Array, or Hash). It doesn’t change the binding of each variable.

Question 14

What is Object Passing?

Answer 14

In ruby, nearly everything is an object. When you call a method with some expression as an argument, that expression is evaluated by ruby and reduced, ultimately, to an object.

The expression can be an object literal, an variable name, or a complex expression; regardless, it is reduced to an object. Ruby then makes that object available inside the method.

This is called passing the object to the method, or, more simply, object passing.

Question 15

Why is Object Passing strategy important?

Answer 15

Most computer languages that employ strict evaluation use pass by value by default. Most of those languages also make it possible to pass by reference when needed.

Few languages are purely pass by value or pass by reference. Understanding which strategy is used (and when) is key to understanding what happens to an object that gets passed to a method.

For example, if the method does something that appears to change the object, is that change local to the method, or does it result in changes to the original object?

Question 16

Describe the difference between ! and ? in Ruby.

Answer 16

Just to clarify, if you see ! or ? at the end of the method, it’s actually part of the method name, and not Ruby syntax. Therefore, you really don’t know what the method is doing, even if it ends in those characters – it depends on the method implementation.

Question 17

what is != and where should you use it?

Answer 17

!= means ‘not equals’, and is used in conditionals

Question 18

What does putting !! before a variable do?

Answer 18

It turns any object into their boolean equivalent

Question 19

What does putting ! before a variable do?

Answer 19

It turns any object into the opposite of their boolean equivalent.

Question 20

What 4 elements of a loop do selection and transformation definitely need?

Answer 20

Selection and transformation both utilize the basics of looping: 
a loop, 
a counter, 
a way to retrieve the current value, 
and a way to exit the loop. 

Keep those four things in mind. In addition, selection and transformation require some criteria; selection uses this criteria to determine which elements are selected, while transformation uses this criteria to determine how to perform the transformation.

Question 21

What’s the difference between .each and .map?

Answer 21

It’s all about their return value.

Both methods take a block as an argument, but what those methods do with the return value of that block is different.

.each will always return the original object it was called upon.

.map will use the return value of the block to perform transformation and put that result in a new collection.

If the return value of the block is true, it will perform some sort of transformation (if applicable) and place it in a new collection. This process is repeated for every element in the original object.
The original collection/ object also remains unchanged , unless the block uses a method that mutates the caller.

Question 22

What can you ask yourself when evaluating code? (5 points)

Answer 22

So what specific pieces of information are we interested in keeping track of? When evaluating code like this, ask the following questions:

1) What is the type of action being performed (method call, block, conditional, etc..)?
2) What is the object that action is being performed on?
3) What is the side-effect of that action (e.g. output or destructive action)?
4) What is the return value of that action?
5) Is the return value used by whatever instigated the action?