Note that this article is by the author of wheezy, a framework that just happens to do quite well on this particular metric.
Yes, I'm a maintainer of Django, so I'm biased too. But look: there's a good argument to be made that parts of (even of all of) Django is too complex. This, however, is not that argument; this is just a made-up metric.
ETA: I misspoke above: McCabe isn't made up. I meant to write that this was a cherry-picked metric. Leaving the above as is because people have already replied to it.
I happen to agree that this kind of measurement is pretty much useless here and that I don't pick my web framework via cyclomatic complexity, but let's not be too disingenuous. He's not making up a metric, it's a thing, and an occasionally useful one IMO.
Sorry, I didn't mean to suggest he was making up a metric.
Yes, McCabe is a real thing. I haven't really found it that useful myself -- I'm not sure that you can adequately measure something fuzzy like "complexity" through static control flow analysis -- but sure, I'm willing to accept that it could be useful in certain circumstances.
What I am saying is that this guy is cherry-picking a specific metric (out of many that he could choose) that makes his tool looks good. I could just as easily come up with a metric that sorts Django to the top of an arbitrary list. That wouldn't be useful, either.
"# of users" is a metric I use to choose which framework to use. For one, it makes it much more likely that a problem I'm having can be solved with a google or forum or stackoverflow search.
I think that alone makes it a much better metric to judge the experience you'll have with a framework than its cyclomatic complexity (at least for a user of a framework, maybe not as a developer)
A bit off topic here, but I feel that this is a terrible metric.
The reason it's impossible to find answers for how to fix problem X in Windows (besides it being terribly designed) is that there are a ton of users who are trying to be helpful and providing bad advice.
Googling for solutions to an Ubuntu problem is starting to look grim too. Read some bug reports on Launchpad and then read some on the Debian bug tracker; there's a clear difference in signal/noise.
Circling back to the original point: if a web framework is simple, you can figure out the problem by just reading the code rather than looking online for solutions (many of which are in the form "oh, framework Y automatically does Z for you so you have to...").
I don't care how simple a framework is. There are always dusty corners that are hard to understand. There will always be bugs. And the ability to get help from fellow users when you hit those is, in my experience, crucial.
The question isn't whether cyclomatic complexity is made up. It is what his "excessive complexity" measure is actually measuring. Is it the sum of all the measures? The max? I would argue that neither of those are useful on their own.
> there's a good argument to be made that parts of (even of all of) Django is too complex.
As long as those complex parts are encapsulated well enough that I don't have to peek 99% of the time, I don't think it matters. I am more concerned about how complex the code I write has to be. If by making the framework complex you can simplify the code I have to write, I am all for it.
Yes, I'm a maintainer of Django, so I'm biased too. But look: there's a good argument to be made that parts of (even of all of) Django is too complex. This, however, is not that argument; this is just a made-up metric.
ETA: I misspoke above: McCabe isn't made up. I meant to write that this was a cherry-picked metric. Leaving the above as is because people have already replied to it.