[TYS] Visibility modifiers

[wtd]

What aspect of Ruby's design makes modifiers like public, private and protected, though present, much less necessary than in languages such as Java, C++, and C#?

What important object-oriented concept am I hinting at?

[ericfourfour]

I realize its been around a month and a half but I thought I could give it a shot.

They're much less necessary because Ruby is dynamically somthing-or-other. I think I read somewhere that these are determined while the program is running and can be changed. The only time you will get an access violation in Ruby is if you call the method.

In other languages they are determined at compile-time. You will receive the access violation at compile-time as well.

[wtd]

Not the answer I was looking for, actually.

Since it's been awhile, I'll post the answer.

I was looking for you to talk about encapsulation. In a typical Java, C++, or C# program, instance variables will all be declared private. At the same time, most if not all of your methods will be public.

In Ruby, this is the default behavior. Instance variables are always private, and methods are by default public.

[ericfourfour]

For curiosities sake, is there an advantage to have the instance variables not private and the methods not public by default in languages like Java, C++, or C#?

[wtd]

It offers choice, and flexibility. Ruby's convenience comes at the cost of that, to some degree. The language's designer clearly thought it a cost worth uncurring.

[Clayton]

although you can declare a method protected if I'm not mistaken?

[wtd]

Yes, methods can be public, private, or protected.

Instance variables, though, are always private.

[ericfourfour]

wtd, you just confused me. If instance variables are always private how come this works?

Ruby:

class Foo   def initialize(baz)     @baz = baz   end end class FooBar < Foo   def to_s     "#{@baz}"   end end puts FooBar.new("Hello World!")

Or am I missing something?

[rdrake]

Freakman, it's a case of "daddy only lets his children touch his privates," really.

[Clayton]

ericfourfour: because the child class inherits Foo, it gains everything that was inside of the Foo class, including instance variables.

rdrake: I think you meant to point that at ericfourfour

[wtd]

The thing ericfourfour is wondering about is why this works, since in other languages, private variables and methods may not be accessed in subclasses.

I suspect I am moderately mistaken, and instance variables are in effect protected in Ruby. In terms of what this makes possible in such a highly dynamic programming language, this is a good thing.