How to Fix Overuse of Global Variables: Step-by-Step Guide

Understand the Impact of Global Variables

• Global variables can lead to unexpected side effects, making the program difficult to understand and debug. Identify sections where global variables are excessively used and could potentially cause problems.
• Evaluate each global variable to determine if it truly needs to be global or if it can be refactored into a local variable within the function scope.

Identify Global Variables

• Search through your codebase for global variable declarations. In C, these are typically found outside any function, often at the top of your source files.
• Use the `extern` keyword to locate where global variables are used across different files to gauge the extent of their usage.

Refactor with Local Scope

• Examine each global variable's purpose and consider transforming it into a local variable where practical. Limit the scope of variables to the smallest extent necessary to reduce data sharing across functions.
• For example, replace: \`\`\`c int globalCounter;

  void incrementCounter() {
  globalCounter++;
  }
  ```
  with:
  ```c
  void incrementCounter(int *counter) {
  (*counter)++;
  }
  ```

  And call incrementCounter with a pointer to a variable in main or another relevant context.

Encapsulate Using Structs and Modules

• Encapsulate related global variables into a `struct`, and pass this struct to functions as needed. This helps contain related data and keeps them together, reducing unnecessary wide access.
• Example: \`\`\`c typedef struct { int counter; float value; } Context;

  void incrementCounter(Context *ctx) {
  ctx->counter++;
  }
  ```

• Create modules: Wrap the data and its related functions into a separate C file. Provide access through functions that manipulate the contained data, promoting encapsulation.

Adopt the Singleton Pattern

• In cases where shared state is genuinely required, employ the Singleton pattern to limit instance creation to just one. This ensures controlled access to the global state.
• Example: \`\`\`c typedef struct { int setting; } SystemSettings;

  SystemSettings *getInstance() {
  static SystemSettings instance = {0}; // Static ensures single instance
  return &instance;
  }
  ```
  Use getInstance() to modify or access SystemSettings consistently.

Leverage Static Variables for File Scope

• Use `static` keyword on variables that are shared within a single file but don't need to be accessible from other files, ensuring they are not visible outside their defining file.
• Example: \`\`\`c static int fileScopedVariable;

  void modifyVariable() {
  fileScopedVariable++;
  }
  ```

  This restricts fileScopedVariable within its containing source file only.

Utilize Thread-Local Storage for Concurrent Programs

• When dealing with multi-threaded programs, global variables can pose concurrency issues. Opt for thread-local storage using `__thread` in GCC or `_Thread_local` in C11 to maintain separate variable instances for each thread.
• Example: \`\`\`c \_\_thread int threadLocalVariable;

  void threadFunction() {
  threadLocalVariable = /_ some value _/;
  }
  ```

  This ensures threadLocalVariable is unique to each thread.

Gradually Refactor and Test

• Refactor incrementally and frequently test your code after altering each global variable to ensure stability and expected behavior of your firmware.
• Automate tests where possible, employing unit tests to validate function outputs remain correct post-refactoring.