You can use these 3d equations with 2D with some minor adjustments;

Point1 = ( x1, y1, 0 );
Point2 = ( x2, y2, 0 );
Point3 = ( x2, y2, -5 );
Dir = direction Vector
spherePos = center sphere
sphereRadius = As it says
ArbitraryPointOnLine = As it says

Normal to Line:

normal = ( Point2 - Point3 ).crossProduct( Point2 - Point1 );
normal = normal / normal.length; // normalize

Distance to Line: (distance is signed, neg means other side )

distance = normal.dotProduct( spherePos - ArbitraryPointOnLine );

To be a hit then distance is less than sphereRadius.

if ( distance < sphereRadius )
{
    spherePos = spherePos + Dir + this->normal * 2.0 * ( sphereRadius - distance );
}

I'm not so hot when it comes to number work. I understand that the dot product is the result of adding two vectors together. I'm not entirely sure why DanielH is using 3d equations, but I assume I can just remove the references to point3.

I'm definately going to need my hand held for a little. I'm not even sure how I would go about writing the routines to calculate the dot product or cross product.

I don't like to just copy and paste code. So if anyone's willing to (try) and explain this to me, that'd be wonderful.

Okay, so for notation I'll refer to a vector as if it had this structure: struct vector { float x; float y; };

The dot product is an operation that takes two vectors and returns a scalar (single number). It takes the components of the vectors, multiplies them together, then sums the results.
In code, that's:

float dot_product(vector a, vector b) {
   return a.x * b.x + a.y * b.y;
}

Abstractly, the dot product is useful because of one interesting identity: dot_product(v, n) = length(v) * length(n) * cos(theta), where theta is the angle between vectors v and n.
(wikipedia has a picture, to help visualize.)
Computing the angle between two vectors, and their lengths, is relatively slow. The dot product is fast and easy. When we use the dot product, we're really using it as a short-cut to get at the length * cos(theta) value.

In our case what we want is really the length(velocity) * cos(theta). We get this out of dot_product(velocity, normal) by ensuring the normal vector is 'normalized' -- has length(n) == 1.
If you'll recall from trigonometry, the length(velocity) * cos(theta) gives the magnitude of velocity in the normal direction, ignoring magnitude of the velocity parallel to the wall.

Now, think back to your collision example. Let's look at a picture:
{"name":"590378","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/7\/1\/717f363fba88a8270ff65394cac2c3a3.png","w":368,"h":187,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/7\/1\/717f363fba88a8270ff65394cac2c3a3"}
In this case, the black arrow represents our ball's velocity. This arrow can be broken down into the red arrow (velocity in to the wall) and the green arrow (velocity parallel to the wall).
When you hit a wall, your motion parallel to the wall is unchanged. Your motion 'in to' the wall is either stopped (inelastic collision) or reversed (elastic collision). So we first want to isolate: how much of the motion is 'in to' the wall? As noted above, that's: dot_product(normal, velocity). Now, that's just a length, but we can make that a vector along the correct direction by simply scaling the normal: normal * dot_product(normal, velocity). This should give us a vector equivalent to the red vector*. Now, to change the black vector so it no longer has any motion 'in to' the wall, we can simply subtract the red vector from the black vector. To change the black vector so the ball bounces away from the wall, simply subtract the red vector an additional time.
In code, that's:
velocity += (1 + elasticity) * dot_product(velocity, normal) * normal;

• you may be concerned that the dot_product(normal, velocity) will be negative, if the normal and velocity are in opposite directions. This is true, but okay, because in this case the normal, when scaled by a negative, will reverse directions and again match the red vector as expected.

Is this making sense?

That's not a dot product. That's the square root of a dot product.

I'm not sure why you think that's len2. Did you mean dotProduct( p2, p2 )?

Well, I have no idea what you're trying to do, here. The dot product can give the squared magnitude of a vector, if you take the dot product of a vector and itself, because then the cos is equal to 1. But that's not really how you're going to be using the dot product for collision detection and response.

edit: Oh ... was that code in response to DanielH's now-mysteriously-absent post?

I goofed and erased my goof. I was hoping it wasn't viewed before I erased it.