The most common errors in undergraduate mathematics

First of all, your statement is meaningless. What exactly does it mean to "know math"?

Here's an alternative explanation: math students do lots of computations, and sometimes make mistakes which they would be able to identify immediately if someone told them "you made a mistake on this line".

Kind of like how all programmers occasionally drop a paren or a semicolon. Does that mean no programmers "know programming"? Of course not.

In fact, if you've never made a stupid mistake programming, odds are you're not a very good programmer because otherwise, you'd have done enough programming that one of these mistakes became inevitable.

The only difference is that most programming is simpler than university-level mathematics, so with a few decades of research we figured out how to use computers to prevent us from making a lot of mistakes without impeding our productivity too much.

For example, from the article:

"In fact, the great mathematician Leonhard Euler published a computation similar to this in a book in 1770, when the theory of complex numbers was still young."

So another way of wording your post: Euler doesn't know math.

Similarly, many of the examples (e.g. calculators) could be interpreted as students knowing too much math, and excepting their tools or others to know the same "math" they know.

Shouldn't be too difficult. I haven't done much teaching and could write a short list. Unfortunately, I don't think it would be very surprising to most people (just as this list probably isn't surprising to most math majors, since we've all made at least one of these "stupid mistakes" before, even when we knew better, especially in the early years. The difference -- and this is reiterated several times -- is that good/smart students notice their error and debug their math/program, instead of just going with it or fudging their result).

Here are a few:

* Not actually thinking of a solution to the problem before starting to write a program; not soliciting requirements.

* ALL of the mistakes covered by this article. Struggling CS majors are often (not always) really, really horrible at math, and this -- more than anything else -- really holds them back from writing correct programs.

* Off-by-one and the functional equivalents

* Infinite loops in exception handling

* not enough input validation; too much input validation

* Reinventing bad versions of existing algorithms (Dijkstra's algorithm is a good example) and in general not enough research before implementation.

* The other side of that coin is taking stack overflow upvoted answers as gospel (basically our equivalent of trusting the calculator)

* Fundamental incomprehension of boolean algebra, which gives rise to all sorts of errors:

incorrect paren placement

Obscenely complicated conditions and/or absurd if conditions because they don't understand boolean algebra (e.g. I've seen conditions that eventually simplify to a || !a)

Complicated programs and grandois bug-hunting because they couldn't figure how a simple boolean expression (there was a post on HN a while back about Javascript == vs === where the developer basically wasted a day going down a rabbit hole he attributed to == vs === but was actually completely avoidable if he had taken an undergraduate discrete math course that hammered home boolean algebra.)

* This page contains a very useful implementation details section which describes some common errors implementing quicksort: http://algs4.cs.princeton.edu/23quicksort/

* As a general rule, any program written by a student containing concurrency is always wrong, unless concurrency was explicitly taught (many schools just have a short unit in a course or two, instead of integrating the topic throughout the curriculum).

I disagree that 0^0 is undefined. I would argue should be 1 and the function 0^x is not continuous at zero. The basic definition of exponentiation for integers is n^m is a product of m instances of n. Because the multiplicative identity is 1, a product of zero numbers is always 1. Therefore 0^0=1.

I use a similar style of writing, including slashed 7s. I wish I could find a nice monospaced font with slashed 7s and 0s, etc.