Why would a draw() or render() method for an object care about how much time has elapsed?

I see the Game.Draw(GameTime gameTime) method passing a GameTime parameter, but I can't imagine why a method concerned with drawing would care about how much time has elapsed. In my mind, it's just supposed to do its best faith effort to draw the current state of the object. The Game.Update(GameTime gameTime) method should be the only method which cares about how much time has elapsed, right?

I was reading the documentation on MSDN (http://msdn.microsoft.com/en-us/library/microsoft.xna.framework.game.draw.aspx) and it said something about fixed time steps:

Update and Draw are called at different rates depending on whether IsFixedTimeStep is true or false. If IsFixedTimeStep is false, Update and Draw will be called sequentially as often as possible. If IsFixedTimeStep is true, Update will be called at the interval specified in TargetElapsedTime, while Draw will continue to be called as often as possible.

Still, I don't see why this matters? Even if my update function gets called 60 times per second and my draw method gets called 1000 times per second, most of those draw calls will just redraw an object which hasn't been updated by the update method since the last draw call. It still shouldn't care about the elapsed game time, right? So, why is game time included in the draw method?

The only thing I can imagine is the draw method could do some sort of interpolation between update frames. Lets say we have a fast moving object, like a bullet, and on update frame 0, it is at position 0. It's moving at 10 units per update frame, so at update frame 1, it'll be at position 10. Lets pretend the draw method runs 10x faster than the update method, so it can draw the position of the object in an interpolated position between the update frames:

Update 0: position = 0;

Draw 0: position = 0;

Draw 1: position = 1;

....

Draw 9: position = 9;

Update 1: position = 10;

Draw 10: position = 10;

Okay, I could buy that explanation if someone gave it to me, but then that gets kind of into a philosophical discussion about whether a draw method should be trying to represent the actual state of an object according to that objects state variables (ie, position value) or its interpolated state between updates. And that raises another question: What happens if you try to click on an object when its being drawn in its interpolated position rather than its actual position and the collision test fails even though on screen it appears to succeed? Granted, I doubt anyone is going to try to click on bullets or this problem may just not be noticeable enough to warrant concern.

The flip side of the argument (and my leaning) is to just say, "Who cares about interpolation between draw frames and update frames?! That's an extra unnecessary CPU cost, which probably is 99% unnoticable when you're updating 60 times per second." And that just brings us full circle back to the original question: Why does the draw method need game time?

I read that article, but it doesn't really answer the question I had. If the human eye can't see the difference in motion after 30 frames per second, and the update function runs at 60fps, and the draw function runs at 1000fps, then even if the draw function redraws the state of objects without interpolation between updates, the motion will be so fluid that the eye won't be able to see a difference. The object being rendered is being rendered exactly where it is at that moment in the update cycle, and that's what we'd want, right?

I hadn't considered using game times for animation though. Logically, it would seem that the draw function would be what controls the animation state, and the animation state is dependent on game time to interpolate between key frames... I think that's a good answer!