Coding Horror: Should Competent Programmers be "Mathematically Inclined"?

Not really, I would say it was a logical inclination not necessarily a mathematical one. And therein is the rub I see programming as logic and problem solving with little to no inherent math unless I am dealing with a mathematical problem. Kind of like the way writing books is not an inherently mathematical in nature even if quite a bit of math is involved in writing a mathematics text book.

This topic seems to come up relatively frequently, and I appreciate Jeff's attempt to add to the conversation with some interestingly selected quotes. Still, the above quote to me highlights how many people, including Jeff, vastly oversimplify the math side of the equation. To put lbrandy's comment slightly differently, knowing a large number of mathematical facts will not make you a good programmer. But to me a basic explanation of “mathematical inclination” could be: a strong understanding of how a mathematical system is governed by rules, and how a problem can be parsed, compartmentalized, and addressed in pieces. It seems fairly self-evident to me that those skills would be shared by anyone whol could be described as even a competent programmer.

I think I agree with you. I would argue that the mathematical ability needed to solve the question above is to realize how to phrase a query to google, find the resulting formula, and turn it into code. You don't need to be able to derive it, for the vast majority of jobs out there.

Also: I've noticed that most programming is equivalent to what in grade school and high school they called a "word problem". Most of the class would groan when we had to do these; I loved them. I suspect if you struggled with word problems, you would have a hard time programming.

Does anyone have an elegant solution?

http://www.zedshaw.com/essays/programmer_stats.html

let A, B be the 2D start and end points of a line segment. Let P be a 2D point.

We think about the problem and graph the problem like this:

            P          
            .          
                       
                       
                       
                       
  A ------------------------ B

            P          
            .         
          / |         
        /   |         
      /    _|         
    /     | |         
  A ------------------------- B
            Q          

  class Vec2( object ):
    def __init__( self, x, y ):
      self.x = x
      self.y = y

  def length( V ):
    return sqrt( V.x*V.x + V.y*V.y )

  def normalize( V ):
    V_len = length( V )
    return Vec2( V.x / V_len, V.y / V_len )

  def dot( V1, V2 ):
    return V1.x*V2.x + V1.y*V2.y

Finally, for clarity and succinctness:

  V1 + V2 represents Vec2( V1.x+V2.x, V1.y+V2.y )

  V1 - V2 represents Vec2( V1.x-V2.x, V1.y-V2.y )

  S * V represents Vec2( S*V.x, S*V.y ), which 
  scales the vector V by a factor of S.  So (2.0 * V)
  would result in a vector in the same direction as V,
  but twice as long.

First, we examine our graph above and write out the known and unknown quantities.

  AB = B - A
  AP = P - A
  AB_len = length( AB )
  AP_len = length( AP )
  Q = ?
  AQ = Q - A
  PQ = P - A

A dot product trick

The trick we'll use to solve this is via the following rule:

For any line that passes through A and B, dot( normalize( B - A ), P - A ) is the distance between A and the closest point on the line to P.

Huh?

Let me explain this thoroughly, so you can add it to your own toolbox for your entire life.

Building an intuitive understanding of vector math

Imagine a line segment AB and a point P. Now picture point Q, which is the closest point to P on a line that passes through A and B, just like the graph above. You can use the dot product to find the distance between A and Q.

First, compute the vector AB by computing (B - A).

You can visualize this as follows. Picture a line segment from point A to point B. Now move it so that A is coincident with the origin (0,0). Since you moved it, you didn't change its length and you didn't change its direction, just its location. So the result of (B - A) could be intuitively described as "a line segment that begins at the origin (0,0) whose length and direction are equal to AB's".

The next step in the dot product trick is to set the length of (B - A) to 1.0, which is "unit length". A few related trivia notes:

- if a vector's length is exactly 1.0, then it is called a "unit vector".

- when you set a vector's length to 1.0, you have just "normalized" the vector.

- normalized vectors are a succinct way to represent a direction in space, whether it be 1D, 2D, 3D, or any other D.

- remember the 2D line equation "y = mx + b"? 'm' is the line's slope. In 2D space, slope is just an alternate way of representing a vector's direction. You can compute a vector V's slope as "rise over run" (V.y / V.x). The only advantage of using slope to represent a direction in 2D is that it's efficient to compute and to use. There are two big disadvantages. First, it's not immediately clear how we'd compute slope in 3D. But more importantly, you can't represent vertical lines with a slope. A vertical line has no 'run', so (V.x / 0.0) == undefined. In programming terms, this could cause problems. So slope is generally avoided for those reasons. I explained it here because I am hoping that it helps you to understand vectors more intuitively.

So, let's enumerate some features of unit length vectors:

- they can be used to represent any direction in space.

- the range of each component of a unit length vector is never outside of [-1.0 .. 1.0].

- if you compute the dot product between a unit length vector and a point, you have projected the point onto the vector. The result of the dot product is the distance between the origin and the closest point on the vector. -- dot product trick

- the dot product of two unit length vectors is equal to the cosine of the angle between them. In other words, let V1 and V2 be unit length vectors. dot( V1, V2 ) == cos( angle between V1 and V2 ). Related facts:

-- the dot product of two unit length vectors is always in the range [-1.0 .. 1.0].

-- if V1 points in the same direction as V2 (that is, V1 == V2), then the dot product is 1.0.

-- if V1 is perpendicular to V2, then the dot product is 0.0.

-- if V1 points in the opposite direction of V2 (that is, V1 == -V2), then the dot product is -1.0.

-- And now, for something fun (and totally optional -- if you don't really understand, don't sweat it. But hopefully it will be interesting rather than confusing): Imagine a light bulb at point L. Now imagine a sphere at point S, being lit by that light bulb. Imagine a point on that sphere, P. You can compute the lightbulb's effect on the sphere at that point as follows:

  L = lightbulb position
  S = sphere position
  P = point on sphere
  Ldir = normalize( L - P )
  surface_normal = normalize( P - S )
  light_intensity = max( 0.0, dot( surface_normal, Ldir ) )
  # that quanitity is called "NdotL" in computer graphics.
  # you would then multiply that quantity by the light's
  # "attenuation", which dims the light as it gets further
  # away.  But that's outside the scope of this example.
  # If you're interested in computer graphics, 
  # the book "Realtime Rendering" is fantastic.

So, let's use our newfound ninja-guru knowledge of vectors and dot products to solve the original problem. After glancing at the above graph again, we remember we need to compute the length of the line segment PQ. One way to solve it is to compute the point Q, then length( Q - P ) is our answer. Getting down to business:

  def dist_point_to_line( A, B, P ):
    # represent the line segment AB as a vector.
    AB = B - A

    # determine the direction of B relative to A.
    AB_dir = normalize( AB ) 

    # compute the distance between A and Q using the dot
    # product trick.  The first argument is a unit length
    # vector.  The second argument is a point *relative to
    # that vector*.
    AQ_len = dot( AB_dir, P - A )

    # Now that we know the length of AQ, we can compute Q.
    # To do this, think of the following equation as "start
    # at A; move along the direction AB_dir by AQ_len units;
    # that position is Q."
    Q = A + AQ_len * AB_dir

    # return the length of PQ.
    return length( Q - P )

There's plenty of cutting-edge stuff to be done that doesn't require an intimate knowledge of mathematics. I would have to say that being good at arithmetic seems to be pretty important in programming, though.

All I'll say is, if you lack math background, then you may well end up doing things like making mincemeat of trying to explain NP-completeness. Just to pick a random example (heh).

Of course, strictly speaking this doesn't mean that mathematics is necessary to do great work. Other qualities - say a good understanding of community (think Flickr), or psychology (Facebook), or design (37Signals) - can be equally useful. But, yeah, that post has "Blub" written all over it.

"Knowing some math can enable you to write some programs" - two separate activities, one benefiting the other. So, as a thought experiment, a non-mathematically inclined programmer with strong engineering / design aesthetics who implements an algorithm that has been prescribed by a mathematically inclined person may often produce a much better result than the mathematically inclined person would on their own.

Programming is related to and benefits from mathematics, but it is not only mathematics. It brings a whole range of skills into play.

I really should stop clicking on Coding Horror links on HN. Jeff is a very different style programmer than I am (and possibly a much better one). But his lack of understanding of the "other programming" is completely infuriating.

Which is often just as much or more in line with philosophical applications of logic than purely mathematical. As I noted in other comment, you could then argue that all philosophy and reasoning is basically conceptual mathematics, but people don't generally view philosophy this way despite the concept dating back 2500 years.

I heard a scary story from a professor of economics who teaches business students. She said she talked about multiplying some value by 20 percent, and wrote on the blackboard "* .2," and then had students ask her why she wrote ".2" on the board when she had just said "20 percent." It probably avoids business logic mistakes to make the steps VERY explicit, so that the businessperson doesn't try to "correct" some error in the formula.