Explaining to students why to use double instead of float (unless there's a very good reason) I keep seeing students use float in lab lessons:

For example, a simple physics calculation of kinematics. Many, many students use float to hold the variables:

float y,g,t,v


etc.

In this specific lab, they idea is for them to see:

$$y(t_{n+1})=y(t_n)+\frac{\Delta y}{\Delta t}\Delta t\approx y(t_n)+v(t_n)\,(t_{n+1}-t_n)$$
with
$$v(t_{n+1})\approx v(t_n)+g*(t_{n+1}-t_n)$$

and then run over times $\{t_i\}_{i=1}^n$ and see that the $y$ values they get are the same as:

$$y(t_n)\approx y(t_1)+v(t_1)\,t_n+\frac{1}{2}g\,t_n^2$$

However, because they use float, they get rounding errors when dealing with small time differences ($\Delta t$). I don't want to get into the whole floating point arithmetics field, because they won't understand that (the word "exponent" would frighten them, to say the least). 

On the other hand, if they use double, then the rounding errors wouldn't be significant (because they aren't dealing with $\Delta t \le 10^{-5}$ of a second). So I try to explain that they should use double, but just stating it as a "rule of thumb" isn't a good idea (because there are cases where one would prefer float)

So, what explanation, as to why they should use double for these things, would be compelling? 

Better yet, is there any way I can show the students such an explanation? (Perhaps an online, interactive demonstration of floating point precision etc. - I couldn't find one)
Luckily this is quite simple to make clear, even if you are steering clear of the IEEE standard.  Honestly, even binary is not needed here.

I would start by borrowing a page from Scheme, and say that we can't make blanket guarantees about the exactness of decimal numbers.  For instance, when we try to express $2/3$ in decimal, and it doesn't work!

All the more so when we are restricted to 10 digits.  We write $0.666666667$.  Why?  It's not that 2/3 is $0.66666667$, it's just that we can't precisely represent $2/3$ in decimal, and at the 10th digit, we just round to get as close as we can.

This is really a problem with any number that has a decimal place.  There are infinite numbers that we can't represent!

The computer has the same problem with decimal numbers as we do.  This isn't a fault of the computer, it's just a feature of floating point numbers, and the computer has to work around it, just like we do. 

Now, we do have a way of increasing that precision: we can increase the number of digits allowed.  It doesn't solve the problem, exactly, but it does get us closer to the true numbers.

That's the difference between a float and a double.  A double allows more digits.  And that's why it's usually a better idea to use a double.