## Saturday, October 17, 2009

### Devilishly Clever

I was doing my usual research on Python when I ran across this recipe to make tail recursive calls not blow the stack in Python: Tail Call Optimization Decorator. I read through the code and thought, "Wow! This is devilishly clever!" As a thought exercise, I think it's awesome. But, it got me thinking about clever and production code. In my opinion, clever is never good or wanted in production code. It's great to learn and understand clever code though. It's a great mental workout to keep you sharp.

So, what's my point with all of this besides to say that clever is bad? The example in the above link is factorial (which as everyone knows is hated by me, but that's another story). But, the amazing thing about factorial examples are that they are dead simple, yet there's several ways to get the answer. Here's a few that I came up with:
`def reg_fact(x):    if x is 1:        return 1    return reg_fact(x - 1) * xdef tail_fact(x):    def func(acc, x):        if x is 1:            return acc        return func(acc * x, x - 1)    return func(1, x)def not_rec_fact(x):    result = 1    for each in range(2, x + 1):        result *= each    return resultdef not_rec_fact_fancy(x):    return reduce(lambda result, each: result * each, range(1, x + 1))import operatordef not_rec_fact_super_fancy(x):    return reduce(operator.mul, range(1, x + 1))`

Each of these compute factorial. Amazingly, there's even more ways than what I listed (the math wizards in the audience know what they are). Now, think about this: Computing factorial is dead simple. What happens when we get to harder problems? Being clever can actually get in the way of making the code easy to understand. It might even kill performance. Let's think back to the devilishly clever code. The performance of making Python tail recursive is awful. Sure, it's pure and tail recursive, but in production code that is deadly. What we want is simple and to the point. It's why I generally like solutions that need less code. There's less noise to get in the way of understanding and generally can mean better performance as well.

Real world problems are hardly ever as straightforward as factorial. The balancing act comes when you drop a solution because it's not working for whatever reason. Raising and catching exceptions so you can have a tail recursive factorial is overkill. It took more code than the non-recursive version. It begs for the programmer to know their tool set and to know how to solve problems in that tool set that are straightforward. Tail recursion is powerful in languages like Haskell and Erlang. But, there's always another way of doing things that can make more sense in the language you are using. In our case, the other ways were just as easy yet more scalable for our tool set. Food for thought the next time you go down the path of clever and end up writing more noise than solution.

## Saturday, October 10, 2009

### Freezing Objects in Python

Someone stop me. I like freezing simple objects or what Eric Evans calls "Value Objects" in his excellent "Domain Driven Design" book. Python doesn't have immutable objects (ala freeze in Ruby) explicitly, but we can easily create it. Python gives us the power to get under its covers. Here's my implementation:
`class ValueObject(object):    def __setattr__(self, name, value):        if name == 'value' and hasattr(self, 'value'):            raise AttributeError("Can not change value attribute")        else:            self.__dict__[name] = value`

Do you have to ask? Yes, I made a test. Here they are:
`import unittestclass Test(unittest.TestCase):    def testSimple(self):        class Cents(ValueObject):            def __init__(self, value):                self.value = value            def __str__(self):                return str(self.value) + " cents"        subject = Cents(5)        self.assertEquals(5, subject.value)        def set_value():            subject.value = 6        self.failUnlessRaises(AttributeError, set_value)`

## Monday, October 05, 2009

### method_missing in Python

OK, I know there is a few implementations of this knocking around on the net already, but I'm in learning mode. So, here's my implementation of Ruby's method_missing:
`class PossibleMissingAttribute(object):    def __init__(self, object, name):        self._object = object        self._name = name    def __call__(self, *args, **kwargs):        return self._object._method_missing(self._name, *args, **kwargs)        def __str__(self):        return self.__class__.__name__ + ": " + str(self._object) + "." + self._name        def __getattr__(self, name):        return None        def __nonzero__(self):        return False    class MethodMissingError(Exception):    def __init__(self, object, name, *args, **kwargs):        self.object = object        self.name = name        self.args = args        self.kwargs = kwargs    def __str__(self):        return repr(str(self.object) + "." + self.name)class Missing(object):    def __getattr__(self, name):        return PossibleMissingAttribute(self, name)    def _method_missing(self, name, *args, **kwargs):        raise MethodMissingError(self, name, *args, **kwargs)`

Three objects and that's it! One to be a placeholder when an argument is missing. One object to represent the MethodMissingError and the last to be an abstract class to inherit from. But, you could easily just put these methods anywhere. Here's my tests:
`import unittestclass TestMissing(unittest.TestCase):    def test_missing(self):       class TestClass(Missing):           def __str__(self):               return self.__class__.__name__           def existing(self):               return "i am"           def _method_missing(self, name, *args, **kwargs):               return args[0]       self.assertEquals("am not", TestClass().missing("am not"))       self.assertEquals("i am", TestClass().existing())       self.assertEquals(None, TestClass().missing.something_else_missing)       self.assertFalse(TestClass().missing)       self.assertEquals("PossibleMissingAttribute: TestClass.missing", str(TestClass().missing))           def test_exception(self):        class TestClass(Missing):           def __str__(self):               return self.__class__.__name__        self.failUnlessRaises(MethodMissingError, lambda: TestClass().missing())`

You've seen my implementation. Here's another one that I found on the net: method_missing in Python
`class MethodMissing(object):    def method_missing(self, attr, *args, **kwargs):        “”" Stub: override this function “”"        raise AttributeError(”Missing method %s called.”%attr)    def __getattr__(self, attr):        def callable(*args, **kwargs):            return self.method_missing(attr, *args, **kwargs)        return callable`

Um, this version is much shorter than mine. It gets the same job done and is more obvious of what it is doing. Simply returning a function on __getattr__ is the best way to go. It's what my PossibleArgumentMissing was doing. But, where I tried to get all fancy using __call__ to mimic a function which caused my version to be longer. I was also trying to get the argument to come back to return false in if conditions and be almost like None (again, I'm learning and was looking at what was possible). Simplest is best.

This was a fun thought exercise. I love all the hooks Python provides to allow you to get underneath the hood if need be. I will be soon doing a post on descriptors and even decorators. I find Python tends to sway heavier on the functional side of programming versus object-oriented. I'm loving the succinct, yet readable code. Too many languages get into the being so terse that they sacrifice readability or debugability (is that a word? Is now!).