Examine the characteristics of large functions

  • 8 minutes

The ability to recognize large functions is an important skill for developers aiming to maintain high code quality. Large functions can lead to various issues, including poor readability, difficulty in maintenance, low reusability, and challenges in testing. Developers who are able to identify functions that exhibit these characteristics can take proactive steps to refactor them into smaller, more manageable components.

Note

It's important for developers to understand how to spot large functions manually rather than relying exclusively on artificial intelligence tools. Knowing the characteristics of large functions that make them problematic helps developers make informed decisions about when and how to refactor code effectively.

Code smells and symptoms

Code "smell" is a term for patterns in code that indicate deeper problems. In code smell terminology, a large function is a "bloater" that usually violates the Single Responsibility Principle. Large functions are a classic code smell.

Here are common indicators that a function is too large or doing too much:

  • Excessive length: A line count of over 30 is a smell. A line count of over 80 is almost always too long.
  • Deep nesting: Multiple levels of indentation (loops within loops, nested if/else/try blocks).
  • Too many parameters: More than 5–6 parameters might indicate the function is aggregating too much logic.
  • Mixed abstraction levels: High-level operations and low-level details interwoven.
  • Commented sections: Comments like // Step 1, // Step 2 suggest multiple responsibilities.
  • Repetition of code patterns: Duplicate logic or repeated blocks that could be extracted.

Note

The presence of comments or region blocks inside a function is a red flag. If you see a function that includes a series of comments like // validate inputs, // do X, // clean up, etc., it’s a sign the function has multiple distinct sections of logic. Each of those sections could probably be a function of its own.

Tools and approaches for finding large functions

There are several ways to identify large functions in a codebase:

  • Manual inspection: Scroll through files and look for long collapsible blocks.
  • Search for comments or TODOs: Developers often leave clues like // this is doing a lot.
  • IDE features: Visual Studio’s "Analyze > Calculate Code Metrics" or Visual Studio Code extensions.
  • Static analysis tools: Linters or analyzers (for example, StyleCop, Roslyn).
  • Artificial intelligence tools: Tools that use artificial intelligence, such as GitHub Copilot, can help identify large functions and suggest refactoring opportunities.
  • Code review feedback: Look for past comments about complexity or maintainability.
  • Metrics: Code metrics, such as cyclomatic complexity and lines of code, can help identify large functions.
  • Code coverage reports: Large functions are often hard to cover fully with tests.

Common "shapes" of large functions

Large functions often follow certain patterns. Here are some common "shapes" to look for:

  • Sequential script: Performs a series of steps one after another.
  • Flag-driven logic: Uses switch or if/else chains to handle multiple modes.
  • Helper-heavy logic: Contains chunks that could be helper methods.
  • Repeated blocks: Similar logic repeated for different data sets or conditions.

Note

Use the “extraction imagination” test: If you can name a block of code as a function, it probably should be one.

Metrics to watch

Cyclomatic complexity, lines of code, and number of parameters are quantifiable metrics that can help identify large functions.

Here are some common thresholds that indicate a high priority for refactoring:

Metric Threshold Why it matters
Lines of code 80+ Indicates complexity and maintainability risk
Cyclomatic complexity 20+ Many independent paths = harder to test
Parameters 6+ Might indicate poor encapsulation or overreach

What is cyclomatic complexity?

Cyclomatic complexity is a software metric that measures the number of independent paths through a function's code. Think of it as counting how many different routes execution can take through your function. There are several tools and IDE features that can calculate cyclomatic complexity for you. For example, in Visual Studio, you can use the "Analyze > Calculate Code Metrics" feature to get cyclomatic complexity values for your methods. In Visual Studio Code, you can use extensions like "CodeMetrics" to analyze your code.

How cyclomatic complexity is calculated

The basic formula is: Cyclomatic Complexity = E - N + 2P

Where:

E = edges (transitions between nodes) N = nodes (sequential code blocks) P = connected components (usually 1 for a single function)

If you don't have access to a tool, there's a simple manual approach that you can use to estimate cyclomatic complexity:

  1. Start with 1.
  2. Add 1 for each if, else if, case (in switch).
  3. Add 1 for each loop (for, while, do-while).
  4. Add 1 for each logical operator (&&, ||) in conditions.
  5. Add 1 for each catch block.

Using complexity as a guide to identify large functions

When the document mentions "Cyclomatic complexity over 10-15 is a red flag," it means:

  • 1-10: Simple, low risk
  • 10+: Start considering refactoring
  • 15+: Definitely needs attention
  • 20+: High priority for refactoring

Cyclomatic complexity is useful because it's objective and measurable, making it an excellent metric for identifying functions that need refactoring.

How to reduce complexity

There are several strategies to reduce the complexity of large functions:

  • Extract methods: Break complex logic into smaller functions.
  • Use polymorphism: Replace complex conditionals with strategy patterns.
  • Early returns: Exit early instead of deep nesting.
  • Simplify conditions: Extract complex boolean logic to well-named variables.
  • Remove flag arguments: Split functions that behave differently based on flags.

Not all large functions are evil

Some large functions are acceptable in specific contexts (for example, performance-critical code). Use judgment. The goal is to make code easier to work with.

Note

If a function is hard to split because everything is tightly interwoven, that’s a sign of high coupling. Copilot’s Ask Mode can help untangle it.

Summary

Large functions can hinder the development process by introducing various challenges. They often lead to decreased readability, increased complexity, and higher maintenance costs. By recognizing the signs of large functions and understanding their impact, developers can take proactive steps to refactor them into smaller, single-purpose functions that are easier to work with.