Complexity

[scenage]

Hi,

I've read the readme about complexity but I'm still unsure what the produced numbers mean?
Is there a guide to the magnitude, thresholds for complexity numbers and what that means for technical debt?

Thanks for the help,
Pat

[boyter]

So the number itself is just a cheaply computed version of cyclomatic complexity https://en.wikipedia.org/wiki/Cyclomatic_complexity

I say cheaply because it's just a count of any branch condition inside the code. Whereas the real cyclomatic complexity value has more too it, but requires a full language parser to calculate.

A while ago I did do a large scale run to see if I could get some idea on languages and counts https://boyter.org/posts/an-informal-survey-of-10-million-github-bitbucket-gitlab-projects/ with the idea of being able to write some sort of guide about what the complexity means. I am still yet to get around to that... one of these days.

For now however, I think it's fairly safe to say that files with lower complexity should mean less technical debt.

For example, I personally use the number when looking at any project to identify where the most problematic files might be. Consider the following,

$ scc --by-file
───────────────────────────────────────────────────────────────────────────────
Language                 Files     Lines   Blanks  Comments     Code Complexity
───────────────────────────────────────────────────────────────────────────────
Go                           5       919      143       155      621        176
───────────────────────────────────────────────────────────────────────────────
main.go                              531       87        82      362        118
caisson_index.go                     178       29        48      101         25
caisson_test.go                      116       14        12       90         26
caisson.go                            76       10        13       53          4
helper.go                             18        3         0       15          3

Give then above I am able to infer that the main.go file has a lot going on in it. Its where I would start looking were I tasked with maintaining this application or if I were trying to improve it or add tests.

However you can also supply the -w argument to get the complexity per line count, which produces the following. Again the main.go file is at the top, but I would also be looking at the caisson_index.go file as it has a high level of complexity and a test file which is also high, suggesting there is something interesting going on there with a lot of tests.

$ scc -w --by-file
─────────────────────────────────────────────────────────────────────────────────────────────────────────────
Language                              Files     Lines   Blanks  Comments     Code Complexity Complexity/Lines
─────────────────────────────────────────────────────────────────────────────────────────────────────────────
Go                                        5       919      143       155      621        176           113.79
─────────────────────────────────────────────────────────────────────────────────────────────────────────────
main.go                                           531       87        82      362        118            32.60
caisson_index.go                                  178       29        48      101         25            24.75
caisson_test.go                                   116       14        12       90         26            28.89
caisson.go                                         76       10        13       53          4             7.55
helper.go                                          18        3         0       15          3            20.00

Perhaps this blog post I wrote might help? https://boyter.org/posts/why-count-lines-of-code/ In it I analysed a project I was not familiar with using scc and its complexity to identify where the problematic files might be.

In short though, the complexity as a total is not very useful, unless comparing to a similar project, or the same project over time. Per file it can be useful to identify where problems in a project might be. If you want to use this to manage technical debt, you could use the number to identify files that potentially should be broken down and then track that this occurs with its complexity coming down over time.

[dvdvdmt]

Hi @boyter I have a very related question. How can we sort files using complexity/lines coefficient? I know that I can use --sort complexity but is there --sort complexityPerLine maybe?

[boyter]

Alas no. Its something I really need to put in there. Might be worth doing it as part of this #370

[BradKML]

@boyter if we are in the subject on complexity, there are other resources that provides a template for it https://github.com/priv-kweihmann/multimetric

• Cyclomatic complexity according to McCabe
• Difficulty according to Halstead
• Effort according to Halstead
• Fan-Out
• Maintainability index
• Metric according to pylint
• Metric according to TIOBE
• Number of delivered bugs according to Halstead
• Time required to program according to Halstead
• Volume according to Halstead

Some not included are

• Koopman Spaghetti Factor https://github.com/ElectronVector/ravioli
• "Churn" (variable changes) https://github.com/simonrenoult/code-complexity
• Cognitive Complexity https://pypi.org/project/cognitive-complexity/
• Indentation Complexity https://github.com/thoughtbot/complexity

[BradKML]

There are also https://github.com/mxmssh/IDAmetrics and this defunct one https://github.com/philbooth/escomplex

• Basic blocks count (function/module)
• Functions count (module)
• Conditions count (function/module)
• Assignments count (function/module)
• Jilb's metric (function/module)
• ABC metric (function/module)
• Pivovarsky metric (function/module)
• Harrison metric (function/module)
• Boundary value metric (function/module)
• Span metric (function/module)
• Global variables access count (function/module)
• Oviedo metric (function/module)
• Chepin metric (function/module)
• Card & Glass metric (function/module)
• Henry & Cafura metric (function/module)
• Cocol metric (function/module)

[boyter]

Those look pretty interesting.

[BradKML]

It is good to take a look with a wider view sometimes.

[dustinpaluch]

Do I understand correctly that -w would help me compare projects of differing size?

[boyter]

To an extent yes. So long as its the same language it should assist there.