ByteDocs

C# Recursion and Trampolines

2026-01-21T00:00:00Z

Understanding recursion is a rite of passage for every developer. It’s elegant, mathematically pure, and… dangerous.

If you’ve ever stared at a StackOverflowException in C#, you’ve met the dark side of recursion. But there is a concept called Tail Recursion that, in theory, fixes this. While functional languages like F# or Haskell handle this automatically, C# needs a bit of "cleverness" to make it work.

This guide will break down the concept of tail recursion, why C# struggles with it, and a clever design pattern called the "Trampoline" to make recursion safe.

Part 1: The "Stack" Problem

To understand tail recursion, you first need to visualize the Call Stack.

Imagine you are reading a book. You find a reference to another book, so you put a bookmark in the current page, open the new book, and start reading. If that book references another, you add another bookmark and open the third book.

In programming, every time a function calls itself, the computer adds a "bookmark" (called a Stack Frame) in memory to remember where it was (local variables, return address).

The Standard Recursive Crash

Let’s look at a classic recursive calculation: Factorial (5! = 5 * 4 * 3 * 2 * 1).

// BAD RECURSION
public int Factorial(int n)
{
    if (n == 1) return 1;

    // The multiplication happens AFTER the recursive call returns.
    // We must "remember" n to multiply it later.
    return n * Factorial(n - 1);
}

If you call Factorial(10000), the computer has to remember 10,000 numbers waiting to be multiplied. Eventually, it runs out of bookmark space. Boom: StackOverflowException.

Part 2: What is Tail Recursion?

Tail recursion is a specific way of writing recursion where the recursive call is the absolute last thing the function does.

If the call is the last action, you don't need to "remember" anything. You don't need a bookmark. You can just close the current book and move to the next one.

Converting to Tail Recursion

To make the Factorial function tail-recursive, we need to pass the "answer so far" (accumulator) into the next step, so we have nothing left to do after the call returns.

// TAIL RECURSIVE (Conceptually)
public int FactorialTail(int n, int accumulator = 1)
{
    if (n == 1) return accumulator;

    // The recursive call is the ONLY thing happening at the end.
    // We don't need to remember 'n' here, it's already used in the calculation.
    return FactorialTail(n - 1, n * accumulator);
}

In languages like F# or C++, the compiler sees this and says: "Aha! You don't need to come back here. I will just replace the current stack frame with the new one." This effectively turns your recursion into a while loop behind the scenes. Zero memory growth.

The Problem: The C# compiler (Roslyn) does not guarantee this optimization. Even if you write perfect tail-recursive code, C# will often still add stack frames, and you will still crash.

Part 3: The "Clever" Solution (The Trampoline)

Since C# won't optimize the stack for us, we can do it ourselves using a design pattern called a Trampoline.

A Trampoline is a loop that runs functions. Instead of function A calling function B directly (and growing the stack), function A returns an instruction to call function B. The Trampoline catches that instruction and runs B.

Imagine a manager (the Trampoline) and a worker (your recursive function):

Manager: "Do the work."
Worker: "I did a bit of work, but I need to do more with these new inputs. Here is the request."
Manager: "Okay, I'll restart you with those inputs."
(The stack never grows because the worker returns to the manager every time.)

A Simple Implementation

We need a wrapper class to represent the "next step."

public static class Trampoline
{
    // Executes the recursive logic in a loop
    public static T Execute<T>(Func<Bounce<T>> func)
    {
        var result = func();
        while (true)
        {
            if (result.IsFinished) return result.Value;
            result = result.NextStep(); // "Bounce" to the next step
        }
    }
}

// Represents the state: either we are done, or we have more work
public class Bounce<T>
{
    public T Value { get; }
    public Func<Bounce<T>> NextStep { get; }
    public bool IsFinished { get; }

    private Bounce(T value, Func<Bounce<T>> nextStep, bool isFinished)
    {
        Value = value;
        NextStep = nextStep;
        IsFinished = isFinished;
    }

    // Helper: We are done!
    public static Bounce<T> End(T result) => new Bounce<T>(result, null, true);

    // Helper: Keep going!
    public static Bounce<T> Recurse(Func<Bounce<T>> next) => new Bounce<T>(default, next, false);
}

Using the Trampoline (Real World Example)

Let's use a real-world scenario. Imagine you are traversing a massive organizational hierarchy (a tree structure) to find a specific employee ID. A standard recursive search might crash if the organization is too deep.

Here is how we use the Trampoline to make it safe:

public class OrgSearch
{
    public static Bounce<string> FindEmployee(int currentId, int targetId)
    {
        // 1. Base Case: Found it
        if (currentId == targetId)
            return Bounce<string>.End($"Found employee {currentId}!");

        // 2. Base Case: Dead end (mock logic)
        if (currentId > 100000)
            return Bounce<string>.End("Not found.");

        // 3. Recursive Step: Return a function that says "Check the next ID"
        // Notice we utilize a lambda () => ... to delay execution
        return Bounce<string>.Recurse(() => FindEmployee(currentId + 1, targetId));
    }
}

// Usage
class Program
{
    static void Main()
    {
        // This would normally crash a stack, but here it runs safely in a loop
        // because the "recursion" happens inside the Trampoline's while loop.
        string result = Trampoline.Execute(() => OrgSearch.FindEmployee(0, 50000));
        Console.WriteLine(result);
    }
}

Summary

Recursion puts "bookmarks" on the stack. Too many bookmarks = Crash.
Tail Recursion is designing your function so no bookmark is needed (the recursive call is the last step).
C# Limitations: C# generally doesn't auto-optimize tail recursion.
The Fix: Use the Trampoline Pattern. Instead of calling yourself deeply, return a "function" that the main loop executes. This turns recursion into iteration, keeping your memory usage flat.

Pro Tip: If you are a beginner in C#, the easiest optimization is often to just rewrite the logic using a while or foreach loop. But understanding the Trampoline pattern opens your mind to how functional programming works and how to manage complex state changes without mutable variables.

Visualizing SonarCloud Metrics with Python - Build a Custom Dashboard for Your Code Quality.

2025-07-03T00:00:00Z

Introduction

In today’s fast-moving software development landscape, tracking code quality isn’t just a nice-to-have—it’s essential. Tools like SonarCloud have become ubiquitous in CI/CD pipelines, providing rich insights into code coverage, technical debt, bugs, and security vulnerabilities. But while SonarCloud’s own dashboards are great, sometimes you need custom analytics, visualizations tailored for your team, or integrations with your existing reporting workflows.

That’s why I built the SonarCloud Metrics Dashboard: an open-source, Python-based tool that fetches metrics from the SonarCloud API, stores them in Azure Table Storage for fast access and historical analysis, and visualizes them with an interactive dashboard built in Streamlit.

In this article, I’ll show you:

Why and how to fetch SonarCloud metrics programmatically
How to design a user-friendly dashboard in Python
How to persist and analyze historical code quality trends
How to share your tool with your team—or the open-source community

Let’s dive in!

Why Build Your Own SonarCloud Dashboard?

SonarCloud provides a powerful UI, but as your organization grows, you might face challenges like:

Needing custom charts or metric combinations beyond what the web UI provides
Wanting to track trends over time for KPIs across multiple repositories or branches
Integrating code quality data into automated reporting, business dashboards, or even team retrospectives

Building your own dashboard means:

Full control over the data, timeframes, and metrics you care about
Ability to combine SonarCloud data with other sources (test coverage, deployment metrics, etc.)
A great excuse to learn Streamlit and modern data visualization in Python

Overview: SonarCloud Metrics Dashboard

Features:

Interactive dashboards: View key metrics (coverage, bugs, vulnerabilities, code smells, etc.) for any project and branch
Historical trends: Track changes over days, months, or a full year
Azure Table Storage integration: Persist data for offline access and fast reloads
Customizable metrics and visualizations: Choose what matters to your team
Open source and ready for you to extend

GitHub Repo

Architecture

Here’s how the main components fit together:

Streamlit Frontend: Interactive web UI for metric selection, filtering, and visualization
SonarCloud API Client: Handles authentication and metric fetching
Azure Table Storage: Stores metric snapshots for historical analysis and caching
Visualization Components: Trend lines, bar charts, box plots, and metric cards (built with Plotly)

Here’s a simplified diagram:

[SonarCloud API] <---> [Python API Client] <---> [Azure Table Storage]
        |                           |
    (live metrics)          (historical cache)
        |                           |
            [Streamlit Dashboard UI]
                    |
            [User: Selects Org/Project/Branch, Visualizes, Exports]

Implementation: Step by Step

1. Prerequisites

Python 3.8+
SonarCloud account (and an API token)
Azure account (for Table Storage, optional but recommended)
Basic knowledge of Python and working with virtual environments

2. Clone and Install

git clone https://github.com/FmoOliveira/SonarCloudDashboard.git
cd sonarcloud-metrics-dashboard
pip install -r requirements.txt

3. Configuration

Create a .env file in the project root:

SONARCLOUD_TOKEN=your_sonarcloud_token
SONARCLOUD_ORG=your_sonarcloud_organization_key
AZURE_STORAGE_CONNECTION_STRING=your_azure_storage_connection_string

4. How the Core Logic Works

a) Fetching Projects and Metrics

The SonarCloudAPI class in sonarcloud_api.py wraps API calls:

class SonarCloudAPI:
    def __init__(self, token: str):
        self.token = token
        ...
    def get_organization_projects(self, organization: str) -> List[Dict]:
        ...
    def get_project_measures(self, project_key: str, branch: str = None) -> Optional[Dict]:
        ...
    def get_project_history(self, project_key: str, days: int, branch: str = None) -> List[Dict]:
        ...

Get all projects in your organization
For a given project/branch, fetch live or historical metrics (coverage, bugs, etc.)
Handles API auth and error cases

b) Storing Metrics for Historical Analysis

azure_storage.py uses Azure Table Storage to cache metrics. This allows:

Super-fast reloads
The ability to analyze trends even if SonarCloud rate-limits your API access
Easy export of all your historical data as CSV

c) Visualization and Dashboard

app.py is your Streamlit entry point:

Sidebar controls: Select organization, project, branch, date range, and which metrics to display
Main area: Metric cards (summary), trend charts, comparison charts, data tables, export buttons
Interactivity: The dashboard updates only when you request it—so you can experiment with filters and metric combinations without unnecessary API calls

Example: Displaying a trend line for “coverage” metric over 30 days:

def create_trend_chart(df: pd.DataFrame, metric: str, project_names: dict):
    ...
    fig = px.line(
        plot_data,
        x='date',
        y=metric,
        color='project_name',
        title=f"{metric.replace('_', ' ').title()} Trend Over Time",
        markers=True
    )
    st.plotly_chart(fig, use_container_width=True)

d) Exporting Your Data

The dashboard includes a download button to export the currently filtered dataset as CSV—ready for further analysis or sharing with your team.

Running the Dashboard

Start the Streamlit app:

streamlit run app.py

Visit the local address provided in the terminal—typically http://localhost:8501.

Customizing and Extending

Want different charts? Extend dashboard_components.py.
Need additional metrics? Update the metric lists in the API and storage classes.
Want to support other backends (e.g., local SQLite, Google Sheets)? Just add a storage module.
Fancy running this in Docker or deploying to Azure Web Apps? Easy—Streamlit supports containerization and cloud deployment.

Try It Yourself!

This project is licensed under the MIT License — use it, fork it, open issues or PRs. All contributions are welcome! See the repo on GitHub.
Clone the repo, set your credentials, and visualize your own organization’s code quality!
Want to integrate this with Slack, Teams, or email digests? The modular design makes that a straightforward extension.
Got feedback or feature ideas? Open an issue on GitHub!

Final Thoughts

This project was first and foremost a learning journey—a way for me to get hands-on with Streamlit, explore its rapid dashboarding capabilities, and see just how easily I could visualize real-world DevOps metrics. Building this SonarCloud dashboard was fun, experimental, and driven by curiosity rather than enterprise requirements.

If you’re considering using this in a production environment, please keep in mind:
This tool was built for fun and learning, not as a ready-made enterprise product. While it’s open-source and flexible, you should review, adapt, and test it thoroughly for your own use case before relying on it for critical reporting or team dashboards.

That said, I hope you find it inspiring—whether you want to tinker, learn Streamlit, or spin up a dashboard for your own data.
If you have suggestions, ideas, or want to improve it, I welcome your feedback and contributions!

Tags:
#Python #DevOps #SonarCloud #CodeQuality #Streamlit #OpenSource #Azure #Dashboard #SoftwareEngineering

C# Flow Control

2025-01-01T00:00:00Z

In this article, we'll explore flow control in csharp, a fundamental topic for any software developer. Effective management of flow control ensures that your program behaves predictably, performs efficiently, and remains readable and maintainable. Based on industry best practices, including insights from Steve McConnell's Code Complete, we'll delve into key flow control structures like if, switch, loops (for, while, do-while, foreach), and the break/continue statements.

The `if` Statement

The if statement is a fundamental control structure that evaluates a Boolean condition and executes a block of code if the condition is true. Writing effective if statements is crucial for maintaining clean, readable, and efficient code.

Example:

int threshold = 25;
int userInput = 25; 

if (userInput == threshold)
{
    Console.WriteLine("The input matches the threshold! 🥳");
}

Best Practices

Use Clear Conditions
The condition inside an if statement should be simple and easy to understand. Avoid writing complex or convoluted expressions that make the logic hard to follow. If necessary, break the condition into smaller, meaningful variables or expressions.

Before:

if ((x > 10 && y < 20) || (x < 5 && y > 30))
{
    // Complex logic...
}

After:

bool isInValidRange = (x > 10 && y < 20);
bool isOutOfRange = (x < 5 && y > 30);

if (isInValidRange || isOutOfRange)
{
    // Clearer logic...
}

Avoid Nested if Statements
While nesting if statements can sometimes be necessary, excessive nesting makes the code hard to follow. Instead of deeply nested if blocks, consider guard clauses—an early return or exit strategy that reduces nesting, which make your code flatter and easier to read.

Before:

if (user != null)
{
    if (user.IsActive)
    {
        if (user.HasPermissions)
        {
            // Perform action...
        }
    }
}

After (Using Guard Clauses):

if (user == null) return;
if (!user.IsActive) return;
if (!user.HasPermissions) return;

// Perform action...

Favor Positive Conditions
Whenever possible, write conditions in a positive manner. Positive conditions are easier to understand and often make your code more readable. For example, instead of negating a condition, use its positive equivalent.

Before (Negative Condition):

if (!isInvalid)
{
    // Logic for valid case...
}

After (Positive Condition):

if (isValid)
{
    // Logic for valid case...
}

Handle Edge Cases and Errors First (Guard Clauses)
Guard clauses allow you to handle edge cases and errors early in your code, preventing unnecessary complexity. By handling invalid conditions upfront, the main logic becomes more readable and manageable.

if (customer == null)
{
    throw new ArgumentNullException(nameof(customer));
}

if (!customer.IsActive)
{
    Console.WriteLine("Customer account is inactive.");
    return;
}
// Continue with core logic for active customers...

Put the Normal Case First
As Steve McConnell suggests in Code Complete, always handle the normal or expected case first in an if block. This keeps the focus on the main flow of logic, while exceptional cases can be handled afterward. This makes the code easier to follow.

Before:

if (!isAuthorized)
{
    // Handle unauthorized case...
}
else
{
    // Main logic for authorized case...
}

After (Normal Case First):

if (isAuthorized)
{
    // Main logic for authorized case...
}
else
{
    // Handle unauthorized case...
}

Consider using switch for multiple conditions
When dealing with multiple conditions related to a single variable, a switch statement is often more readable than a series of if-else blocks. It provides a structured way to handle multiple cases, making it easier to see all the conditions at a glance.

Before (Multiple if Statements):

if (status == "Pending")
{
    // Handle pending status...
}
else if (status == "Approved")
{
    // Handle approved status...
}
else if (status == "Rejected")
{
    // Handle rejected status...
}

After (switch Statement):

switch (status)
{
    case "Pending":
        // Handle pending status...
        break;
    case "Approved":
        // Handle approved status...
        break;
    case "Rejected":
        // Handle rejected status...
        break;
    default:
        // Handle unknown status...
        break;
}

Refactor Complex if Logic
If your if conditions become too complex, it's a sign that you should refactor the code. Extracting logic into separate methods or using design patterns (like the Strategy Pattern) can simplify decision-making and improve code readability.

if (ShouldSendNotification(user, notificationType))
{
    SendNotification(user, notificationType);
}

Test and Document Your Conditions
Always ensure that your conditions are thoroughly tested, including edge cases, null checks, and unexpected inputs. Use comments to document complex conditions or edge cases, making your code easier to maintain.

// Ensure the user is not null and has the necessary permissions
if (user != null && user.HasPermissions)
{
    // Perform action...
}

The `switch` Statement

The switch statement is a control structure used to select one of many code blocks to execute based on the value of a variable. It's particularly useful when you need to compare a variable against several discrete values.

Example:

string status = "Approved";

switch (status)
{
    case "Pending":
        Console.WriteLine("The request is pending.");
        break;
    case "Approved":
        Console.WriteLine("The request is approved.");
        break;
    case "Rejected":
        Console.WriteLine("The request is rejected.");
        break;
    default:
        Console.WriteLine("Unknown status.");
        break;
}

In this example, the program evaluates the value of status and executes the corresponding block of code. If none of the cases match, the default block is executed.

In recent versions of csharp (beginning with csharp 8.0), the switch statement has undergone significant enhancements through the integration of pattern matching. These improvements allow developers to write more concise and expressive code by leveraging switch expressions. This advancement simplifies the handling of multiple conditions and complex pattern matching scenarios, often reducing the verbosity commonly associated with traditional switch statements.

The introduction of switch expressions not only shortens the code but also enhances its readability and maintainability, making it a powerful tool for developers working with conditional logic.

public string GetDayName(int day) => day switch
{
    1 => "Monday",
    2 => "Tuesday",
    3 => "Wednesday",
    _ => "Unknown"
};

Pattern Matching with `switch` Expressions

switch expressions become even more powerful with pattern matching, allowing for checks beyond simple equality, such as type checks and property matches. For example:

public string DescribeNumber(object number) => number switch
{
    int n when n > 0 => "Positive integer",
    int n when n < 0 => "Negative integer",
    double d => "Double",
    null => "No value",
    _ => "Unknown type"
};

This example uses relational patterns and type patterns to match different types of numbers and handle them accordingly.

Advanced Pattern Matching:

Relational Patterns: You can check ranges of values using conditions like < and >.

string WaterState(int temperature) => temperature switch
{
    < 32 => "Solid",
    > 212 => "Gas",
    _ => "Liquid"
};

Property Patterns: These allow matching based on object properties.

public record Person(string Name, int Age);

string CheckPerson(Person person) => person switch
{
    { Age: >= 18 } => "Adult",
    { Age: < 18 } => "Minor",
    _ => "Unknown"
};

Tuple Patterns: Useful when working with multiple values.

string ClassifyCoordinates(int x, int y) => (x, y) switch
{
    (0, 0) => "Origin",
    (_, 0) => "On the X axis",
    (0, _) => "On the Y axis",
    _ => "Somewhere in the plane"
};

Best Practices for `switch` Statements:

Always Include a default Case: A default case ensures that your program handles unexpected or unhandled values gracefully.
Keep Cases Short and Concise: Each case in a switch should perform a specific task. If the logic is complex, consider refactoring it into a separate method to keep the switch statement readable.
Use Pattern Matching: Leverage csharp 8.0+ features for more expressive code.

Loops in csharp

csharp provides four primary looping structures: for, while, do-while, and foreach. Each has its specific use cases and best practices.

The `for` Loop

A for loop repeats a block of code a specific number of times, which makes it ideal for iterating over arrays or performing a task a known number of times.

Example:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine($"Iteration {i + 1}");
}

Best Practices for `for` Loops:

Use Descriptive Variable Names: Instead of i, use meaningful variable names if the context requires it (e.g., index or counter), especially in nested loops.
Avoid Magic Numbers: Rather than hardcoding values like 5 directly in the condition, use a named constant or variable to improve readability.

int numberOfIterations = 5;

for (int index = 0; index < numberOfIterations; index++)
{
    Console.WriteLine($"Iteration {index + 1}");
}

The `while` Loop

A while loop is particularly useful when you do not know the number of iterations in advance because it continues to execute as long as its condition remains true. This makes it ideal for scenarios where the termination condition is not based on a predefined number of iterations, but rather on a dynamic or external condition being met during execution.

int counter = 0;

while (counter < 5)
{
    Console.WriteLine($"Counter: {counter}");
    counter++;
}

Best Practices for `while` Loops:

Ensure Your Loop Will Eventually Terminate: Always update variables inside the loop to ensure the condition will eventually become false, avoiding infinite loops.
Consider Loop Conditions Carefully: If the condition may never be met or is complex, consider adding a safety mechanism or logging to debug the loop's behavior.

The `do-while` Loop

A do-while loop is similar to a while loop, but it guarantees that the code inside the loop will run at least once, even if the condition is false initially.

int userInput;
do
{
    Console.WriteLine("Enter a number greater than 10: ");
    userInput = int.Parse(Console.ReadLine());
} while (userInput <= 10);

Console.WriteLine($"You entered: {userInput}");

Best Practices for `do-while` Loops:

Use When You Want at Least One Execution: The primary use case for a do-while loop is when you need the loop to execute at least once, even if the condition is not met from the start.

The `foreach` Loop

The foreach loop is a more convenient way to iterate over collections, such as arrays, lists, or dictionaries. It automatically iterates through each element in the collection.

string[] fruits = { "Apple", "Banana", "Cherry" };

foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}

Best Practices for `foreach` Loops:

Use When Iterating Over Collections: A foreach loop is simpler and more readable than a for loop when iterating over collections because you don't need to manage index values manually.
Avoid Modifying Collections Inside a foreach: Modifying the collection (e.g., adding or removing elements) during iteration can lead to runtime exceptions. If you need to modify the collection, consider using a for loop or iterating over a copy of the collection.

The `break` and `continue` Statements

csharp's break and continue statements offer precise control over loops and switch statements. break exits a loop or switch case early, while continue skips to the next iteration. These tools, when used judiciously, can significantly enhance code efficiency and readability.

The `break` Statement

The break statement is used to immediately exit the loop or switch statement in which it is placed. When the break statement is executed, control is transferred to the code following the loop or switch block.

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break; // Exit the loop when i is 5
    }
    Console.WriteLine($"Iteration {i}");
}

Best Practices for Using `break`:

Use break to Exit Early from Loops When Necessary: You can use break to terminate loops early when a certain condition is met. This can improve performance if continuing the loop would be unnecessary.
Avoid Overusing break in Complex Loops: While break can simplify loop logic, overusing it can make loops harder to understand. Use it sparingly and consider refactoring complex loops to improve readability.
Always Include break in switch Statements: Ensure that each case in a switch statement has a break (or equivalent control flow like return or throw), unless you intend to let execution fall through to the next case.

The `continue` Statement

The continue statement skips the remaining code inside the loop for the current iteration and proceeds to the next iteration. Unlike break, continue does not terminate the loop, it just skips to the next loop cycle.

for (int i = 0; i < 10; i++)
{
    if (i % 2 == 0)
    {
        continue; // Skip the rest of the loop body for even numbers
    }
    Console.WriteLine($"Odd number: {i}");
}

Best Practices for Using `continue`:

Use continue to Skip Unnecessary Processing: When certain iterations in a loop don't require further processing, continue can help you skip unnecessary steps, making the loop more efficient.
Avoid Overusing continue: While continue can simplify loops, excessive use may make the loop logic harder to follow. Ensure that it is used only when necessary to improve clarity.
Prefer continue Over Complex if Logic: In some cases, using continue is clearer than adding multiple nested if conditions. For example, instead of writing complex conditional logic inside a loop, you can use continue to skip iterations early.

Before (Complex if Condition):

for (int i = 0; i < 10; i++)
{
    if (i % 2 != 0)
    {
        // Perform action only for odd numbers
        Console.WriteLine(i);
    }
}

After (Using continue for Clarity):

for (int i = 0; i < 10; i++)
{
    if (i % 2 == 0)
    {
        continue; // Skip even numbers
    }
    Console.WriteLine(i); // Perform action only for odd numbers
}

Conclusion

Mastering flow control in csharp is vital to writing clean, maintainable, and efficient code. By following these best practices and leveraging modern csharp features, you can significantly improve your code quality and readability.

References

McConnell, S. (2004). Code Complete (2nd ed.). Microsoft Press.
Microsoft. (n.d.). Pattern matching. Microsoft Learn. https://learn.microsoft.com/en-us/dotnet//language-reference/operators/patterns