Python 129 - Once More

I’m going to do the tiny object for the nearest code. I just want to see how it looks. Talk about gilding the lily.

We’ll TDD it, I think, copying the existing nearest tests. New class name: Targeter.

It will just handle a single coordinate, either x or y: that will be enough to try out what I’m interested in. Here’s the first cut, passing its tests:

class Targeter:
    def __init__(self, shooter_coordinate, target_coordinate, screen_size):
        self.to_coordinate = target_coordinate
        self.from_coordinate = shooter_coordinate
        self.size = screen_size
        self.half = self.size / 2

    def nearest(self):
        direct_distance = abs(self.to_coordinate - self.from_coordinate)
        if direct_distance <= self.half:
            return self.to_coordinate
        elif self.from_coordinate >= self.half:
            return self.to_coordinate + self.size
        else:
            return self.to_coordinate - self.size

What I wanted to try was some Extract Method action, hoping for more clarity. This may take a few tries on the names.

OK. Here’s the revised nearest method from my new object:

    def nearest(self):
        if self.target_is_near:
            return self.target_coordinate
        elif self.we_are_past_center:
            return self.target_on_high_side
        else:
            return self.target_on_low_side

Now it seems to me that that’s about as short and clear as it could be. Of course, we wonder a bit about how it got that way. But first, here’s the test, so you can see how we use this thing:

    def test_can_choose_nearest_scalar_target(self):
        target = 100
        screen_size = 500
        shooter = 200
        assert Targeter(shooter, target, screen_size).nearest() == 100
        shooter = 400
        assert Targeter(shooter, target, screen_size).nearest() == 100 + 500
        target = 400
        shooter = 100
        assert Targeter(shooter, target, screen_size).nearest() == 400 - 500

Same numbers, new notation.

How did we do it? Methods, converted to properties:

class Targeter:
    def __init__(self, shooter_coordinate, target_coordinate, screen_size):
        self.target_coordinate = target_coordinate
        self.from_coordinate = shooter_coordinate
        self.size = screen_size
        self.half = self.size / 2

    def nearest(self):
        if self.target_is_near:
            return self.target_coordinate
        elif self.we_are_past_center:
            return self.target_on_high_side
        else:
            return self.target_on_low_side

    @property
    def target_is_near(self):
        return self.direct_distance <= self.half

    @property
    def direct_distance(self):
        return abs(self.target_coordinate - self.from_coordinate)

    @property
    def we_are_past_center(self):
        return self.from_coordinate >= self.half

    @property
    def target_on_high_side(self):
        return self.target_coordinate + self.size

    @property
    def target_on_low_side(self):
        return self.target_coordinate - self.size

Would I ever go that far? Well, in Python, I might not. In Smalltalk, I could imagine it, because Smalltalkers just love lots of tiny methods.

We might prefer a simpler calling sequence, like this:

    def test_best_target(self):
        target = 100
        screen_size = 500
        shooter = 200
        assert Targeter.best_target(shooter, target, screen_size) == 100
        shooter = 400
        assert Targeter.best_target(shooter, target, screen_size) == 100 + 500
        target = 400
        shooter = 100
        assert Targeter.best_target(shooter, target, screen_size) == 400 - 500

That’s easily done:

class Targeter:

    @classmethod
    def best_target(cls, shooter_coordinate, target_coordinate, screen_size):
        return Targeter(shooter_coordinate, target_coordinate, screen_size).nearest()

We could fiddle with the names. But that would be silly, wouldn’t it?

All I really wanted to do was to get to this method, which I personally feel is very nice but almost certainly over-polished:

    def nearest(self):
        if self.target_is_near:
            return self.target_coordinate
        elif self.we_are_past_center:
            return self.target_on_high_side
        else:
            return self.target_on_low_side

I don’t know whether to be proud or ashamed. Maybe both!

Will I plug it in? Very possibly. But, Ron! It’s certainly less efficient with all those method calls! Right, every two seconds or whatever, when we fire a targeted missile. Do I care about something that is microseconds slower every couple of seconds? Probably not.

See you next time!