Start with simple object attributes, then convert to attribute functions
using get/set-ers when needed.
Agreed, do a search on some keywords plus "considered (evil|harmful)"
I consider get/set harmful 99% of the time, so read the rest of this
post as opinion.
Getter/Setters seem object oriented, but they usually aren't.
You are hiding nothing, you aren't abstacting anything either.
Someone is still depending on accessing a very particular attribute of
your class. If the same amount of code has to be changed when you
alter a getset method as when you alter a member your getset
methods are just adding obscurity and call overhead with no reward.
The object you are calling should get its state explicitly passed in
during __init__, and if it needs something else it should be passed in
on a method call. get/set methods are typically an indication that an
instance is 'peeking' at something else to figure out what to do.
Make "grep counts" your mantra. Passing things only at the time they
are actually needed makes things obvious.
import amodule
def myfunc(self):
# obvious, only gets what it needs.
amodule.launch_debugger(use_globals=self.vars)
import amodule
def myfunc(self):
# has to get 'vars' from self, might silently grow to do evil later.
amodule.launch_debugger(self)
If you limit what methods can use to what they are explicitly given it
also makes writing unit tests much, much easier.
-jackdied
