From: "Jan E." <lists@...>
Date: 2012-05-17T10:13:26+09:00
Subject: Re: what is going wrong here? The case of the noob not understanding initialize

roob noob wrote in post #1061072:
> use OFB instead of CTR please you need the cutting edge version of
> OpenSSL for CTR to work

OFB gives me the right output for all three variants:

whatever
�a�xtT��
�a�xtT��
whatever



> the method is *always* dependent on outer variables regardless of if
> they are passed with @ or with ().

No, without the instance variables, the method will always return the 
same value for the same arguments. Its behaviour doesn't depend on outer 
variables.

Compare these two methods:

$z = 10
def add(x, y)
  x + y
end
def add2(x, y)
  x + y + $z
end

The first method doesn't use instance variables. add(1, 1) will always 
return 2, no matter how the outer world looks like. But add2(1, 1) may 
yield different results, depending on the value of $z.

Another important difference is that "() methods" have a clean 
interface: all input comes from the arguments, and all output is in the 
return value. There are no "magical" values from the outside involved. 
This is much easier to track and test, especially if you haven't written 
the code yourself.



> I do agree that
> .instance_variable_get() is ugly though and I am going through my code
> and removing it where possible, making the called methods end on what I
> want to get from them. In some cases I need to get multiple instance
> variables though, maybe I should split it up into many smaller methods
> in these cases? How else am I supposed to get multiple instance
> variables from a method in one class to a method in another class?

Methods can also return hashes or arrays. This way you can pass multiple 
values.

For example:


# this methods calculates the minimum, maximum and average
# of a list of numbers

def min_max_avg(values)
  {
    min: values.min,
    max: values.max,
    avg: values.reduce(:+).to_f/values.length
  }
end



> I can't use () in these cases without greatly decreasing the flexibility
> of my code, since () assumes that I have a class/method to send the
> resulting variables to and .instance_variable_get() only assumes that I
> have the variables to get. What if in some cases I want the resulting
> variables to go one place and in other cases I want them to go somewhere
> else? "Pulling" from the calling method with .instance_variable_get
> makes more sense than "pushing" from the called method with () in these
> cases.

I do understand the purpose of this idea, and it may even be technically 
efficient. But it's still bad style, because how the methods works is 
obscure. Imagine you're a programmer using this code from somebody else. 
What do you find easier to use:

"encrypt(message) returns the AES-256 encryption of message"

or

"Set the @message variable in an instance of Encrypt and call the 
encrypt() method. After this, get the result from the @ciphertext 
variable. Be careful not to change the variables in between."

By the way, you shouldn't use "instance_variable_get" at all. This is 
simply the wrong method for your purpose. Define getter methods for the 
variables (via attr_reader) and call them.

-- 
Posted via http://www.ruby-forum.com/.