Return to Answer

Nope.

Here's why. A derivative of O(n²) and O(n³) will tell you that the difference of these upper bounds is 1. The problem is I don't care about that difference. I care about the differences between O(n²) and O(n!). Neither of which I like (I like O(n*log n)) but O(n!) is nasty when n is significant (sometimes n isn't and then no one cares about any of this). O(n²) and O(n¹⁰) are close enough that I simply don't care. So no, derivatives here put emphasis on the wrong details. I'm not concerned with rates of change. I'm concerned with categories of change.

The reason why is because code in the n log n category is often as good as it gets (unless there is a trivial solution) and the others are usually leaving room for significant improvement. That is, when n is big enough that anyone cares.

In fact I have 3 categories I concern myself with: trivial, optimized, crap.

Find a way to help me sort algorithms into those and I'll get you a Turing award.

Nope.

Here's why. A derivative of O(n²) and O(n³) will tell you that the difference of these upper bounds is 1. The problem is I don't care about that difference. I care about the differences between O(n²) and O(n!). Neither of which I like (I like O(n*log n)) but O(n!) is nasty when n is significant (sometimes n isn't and then no one cares about any of this). O(n²) and O(n¹⁰) are close enough that I simply don't care. So no, derivatives here put emphasis on the wrong details. I'm not concerned with rates of change. I'm concerned with categories of change.

The reason why is because code in the n log n category is often as good as it gets (unless there is a trivial solution) and the others are usually leaving room for significant improvement. That is, when n is big enough that anyone cares.

In fact I have 3 categories for applied algorithms: trivial, optimized, crap.

Find a way to help me sort applied algorithms into those and I'll get you a Turing award.

Nope.

Here's why. A derivative of O(n²) and O(n³) will tell you that the difference of these upper bounds is 1. The problem is I don't care about that difference. I care about the differences between O(n²) and O(n!). Neither of which I like (I like O(n*log n)) but O(n!) is nasty when n is significant (sometimes n isn't and then no one cares about any of this). O(n²) and O(n¹⁰) are close enough that I simply don't care. So no, derivatives here put emphasis on the wrong details. I'm not concerned with rates of change. I'm concerned with categories of change.

The reason why is because code in the n log n category is often as good as it gets (unless there is a trivial solution) and the others are usually leaving room for significant improvement. That is, when n is big enough that anyone cares.

Nope.

Here's why. A derivative of O(n²) and O(n³) will tell you that the difference of these upper bounds is 1. The problem is I don't care about that difference. I care about the differences between O(n²) and O(n!). Neither of which I like (I like O(n*log n)) but O(n!) is nasty when n is significant (sometimes n isn't and then no one cares about any of this). O(n²) and O(n¹⁰) are close enough that I simply don't care. So no, derivatives here put emphasis on the wrong details. I'm not concerned with rates of change. I'm concerned with categories of change.

The reason why is because code in the n log n category is often as good as it gets (unless there is a trivial solution) and the others are usually leaving room for significant improvement. That is, when n is big enough that anyone cares.

In fact I have 3 categories I concern myself with: trivial, optimized, crap.

Find a way to help me sort algorithms into those and I'll get you a Turing award.

Nope.

Here's why. A derivative of O(n²) and O(n³) will tell you that the difference of these upper bounds is 1. The problem is I don't care about that difference. I care about the differences between O(n²) and O(n!). Neither of which I like (I like O(n*log n)) but O(n!) is nasty when n is significant (sometimes n isn't and then no one cares about any of this). O(n²) and O(n¹⁰) are close enough that I simply don't care so no, derivatives here put emphasis on the wrong details. I'm not concerned with rates of change. I'm concerned with categories of change.

The reason why is because code in the n log n category is often as good as it gets (unless there is a trivial solution) and the others are usually leaving room for improvement. That is, when n is big enough that anyone cares.

Nope.

Here's why. A derivative of O(n²) and O(n³) will tell you that the difference of these upper bounds is 1. The problem is I don't care about that difference. I care about the differences between O(n²) and O(n!). Neither of which I like (I like O(n*log n)) but O(n!) is nasty when n is significant (sometimes n isn't and then no one cares about any of this). O(n²) and O(n¹⁰) are close enough that I simply don't care. So no, derivatives here put emphasis on the wrong details. I'm not concerned with rates of change. I'm concerned with categories of change.

The reason why is because code in the n log n category is often as good as it gets (unless there is a trivial solution) and the others are usually leaving room for significant improvement. That is, when n is big enough that anyone cares.