|
C.3 Coding Insights |
Maximizing Code Quality with SheerPower's Option Insights
Coding Insights empowers developers to write higher-quality code by providing real-time guidance during compilation. This feature reinforces best practices and encourages efficient coding habits, making development smoother and more productive.
SheerPower’s option insights enables the compiler to collect
detailed metrics during compilation, generating a comprehensive
Coding Insights Report. By analyzing code complexity and
structure, this tool helps developers create code that is easier to
develop, test, and maintain—enhancing both efficiency and reliability.
Enabling Option Insights
To enable insights, simply add this to the top of your program:
SheerPower tracks various metrics during compilation and automatically generates a detailed insights report at the end of the process.
Generated Report
The insights report provides the following key details:
- Lines of code, number of routines, and variables.
- Complexity level per routine.
- List of most complex routines.
- List of unused variables -- they are given values but never used.
- List of unused routines -- they are defined but never called.
- Literal counts.
- Suggestions for optimization.
- and much more.
(Show/Hide An Interactive Insights Report)
Interpreting the Scores
The report assigns a Complexity Level score to each routine:
(Show/Hide Understanding Complexity Level)Understanding Complexity Level
Complexity Level (CL) is a way to measure how complicated
a routine (or function) is. It counts the number of decision points
in the code—such as if and else statements.
The more decisions your code makes, the more complex it becomes. A higher complexity score usually means the code is harder to read, test, and maintain.
How is the Complexity Level Calculated?
Every routine starts with a complexity of 0. Then:
- Each
ifandelse, etc. adds to the score. - More nested logic (deeply indented blocks) increases the score even more.
Example:
This routine has CL = 2 (+1 for the if statement).
What to Do If Complexity is Too High?
If a routine’s Complexity Level is high (21+ or more), the code is getting difficult to read, test, and maintain.
Ways to Reduce Complexity
-
Split large routines into smaller ones using
local routinesMove parts of the logic into separate local routines. Each routine should focus on one task only.
-
Avoid Deep Nesting
Instead of many nested
ifstatements, use early exits (guardstatements). This makes the code flatter and easier to follow. -
Use
caseInstead of MultipleifStatementsBefore:
if code = "A" then print "Alpha" else if code = "B" then print "Beta" else if code = "C" then print "Gamma" else print "Unknown" end ifAfter (Simplified with
case):select case code case "A" print "Alpha" case "B" print "Beta" case "C" print "Gamma" case else print "Unknown" end selectThe CL is now lower! The code is easier to follow.
-
Remove Unnecessary Logic
If logic isn’t needed, remove it! If an
ifstatement always leads toreturn, rewrite it more cleanly.
Summary
- The Complexity Level counts decision points (
if,else, etc.). - Lower complexity means easier-to-read, test, and maintain code.
- Reduce complexity by splitting routines into smaller local routines, avoiding deep nesting,
using
select case, and keeping logic simple.
- 0-10: Simple (Good)
- 11-20: Moderate (Review for improvement)
- 21+: Critical (Refactoring needed)
The report assigns a Lines of Code (Adjusted) status to each routine:
- 1-30: Simple (Good)
- 31-90: Moderate (Review for improvement)
- 91+: Critical (Refactoring needed)
The report assigns a Literals Usage status to each routine:
- 1-15: Minimal (Good)
- 16-30: Moderate (Consider refactoring)
- 31+: Excessive (Refactoring needed)
Best Practices
To make the most of option insights, consider the
following best practices:
- Regularly check complexity scores during code development.
- Refactor high-complexity routines to improve maintainability.
- Use named constants for frequently repeated literals.
- Minimize deep nesting in logic-heavy functions.
- Review the insights report often to ensure code quality.
Conclusion
SheerPower's option insights provides
a valuable way to assess and optimize code complexity.
By reviewing the generated report and applying best
practices, developers can maintain clean, efficient,
and scalable SheerPower applications.
|
Hide Description
|
|
|
Enter or modify the code below, and then click on RUN |
|
Looking for the full power of Sheerpower?
Check out the Sheerpower website. Free to download. Free to use. |
