Firmware Quality, Reduce Bug Opportunity by Reducing/Eliminating "extern". Suggest Using Classes

[ForrestErickson]

Describe the bug

Global can be the source of coding problems. See next comment below "Summary: Why globals are bad"

A clear and concise description of what the bug is.
Short Summary of the expected behavior:
Lee asked an AI the following:

Q. in general in programming C++ can you avoid using extern declaration by creating classes...

The AI Answer:

In C++, the extern keyword is used to declare a variable or function that is defined in another translation unit (a .cpp file). This is primarily used for global variables and non-member functions to establish their linkage across different source files.

While you cannot directly use extern with class definitions themselves, creating classes can significantly reduce or eliminate the need for extern declarations, especially for managing data and functionality across multiple files.

Here's how classes achieve this:
Encapsulation of Data: Instead of using extern to declare global variables that are accessed directly from multiple files, you can encapsulate that data within a class. Instances of this class can then be created and passed between functions or accessed through well-defined interfaces (member functions).
Member Functions: Class member functions operate on the class's data. If you have functions that need to interact with shared data, making them member functions of a class that holds that data allows you to manage access without resorting to global functions and extern declarations.
Singletons (with caution): For truly global, single-instance data or resources, you can implement the Singleton design pattern using a class. This provides a controlled, single point of access to the shared resource, eliminating the need for extern declarations for that resource. However, Singletons should be used sparingly as they can introduce tight coupling and make testing more difficult.
Passing Objects: Instead of relying on extern variables, you can pass instances of your classes (containing the relevant data and functions) as arguments to other functions or store them as member variables in other classes. This promotes better organization and reduces reliance on global state.
In essence, by structuring your code with classes and objects, you move from a global, file-based sharing model (where extern is often needed) to an object-oriented, instance-based model, where data and functionality are encapsulated and managed within objects. This generally leads to more maintainable, modular, and less error-prone code.

AI responses may include mistakes.

Exposure to use of "extern"

Instances of "extern" in the code as of 20251102

[ForrestErickson]

Summary: Why globals are bad

Global variables are generally considered a bad practice in software development due to several significant drawbacks:

• Reduced Code Readability and Understandability: Global variables can be accessed and modified from anywhere in the program. This makes it difficult to trace where a variable's value might have been changed, making the code harder to understand and reason about, especially in larger projects.
• Increased Coupling and Reduced Modularity: Functions or modules that rely on global variables become tightly coupled to the global state. This makes it challenging to reuse these components in different contexts or to test them in isolation, as they always depend on the global environment.
• Debugging Difficulties: When a bug occurs related to a global variable, identifying the source of the error can be a complex and time-consuming process. Any part of the program could potentially be responsible for setting the variable to an incorrect value.
• Concurrency Issues in Multi-threaded Environments: In multi-threaded applications, multiple threads might attempt to access and modify a global variable simultaneously. This can lead to race conditions and unpredictable behavior if proper synchronization mechanisms are not implemented, adding complexity and potential for bugs.
• Namespace Pollution: Global variables occupy a global namespace, increasing the risk of name collisions, especially when integrating code from different sources or libraries. This can lead to unexpected overwriting of variables or confusion about which variable is being referenced.
• Violations of Unit Testing Principles: Global variables often make it difficult to write independent and repeatable unit tests. Tests for functions that depend on global state require setting up and tearing down that global state, potentially introducing dependencies between tests and making them less reliable.
• Reduced Reusability: Code that heavily relies on global variables is less reusable because it carries along its specific global environment. To use such code in a different project or context, the entire global state might need to be replicated or adapted.

AI responses may include mistakes.

[ForrestErickson]

A Library ' Class To Help

There appears to be a class to help with this problem.

Q to an AI

how is the configmanager class used to reduce global variables

A from AI

A class (or similar design pattern like the Singleton) reduces global variables by encapsulating related configurations within a single object, which is then accessed as a local or instance variable instead of a global one. This approach limits the scope of the configuration data, making it easier to manage, read, and trace, while preventing naming conflicts and "spooky action at a distance" where one part of the code unintentionally affects another. [1, 2, 3, 4, 5]
How a class works

• Encapsulation: It bundles all related configuration data and the methods to access or modify it into one class.
• Instance variable: Instead of using a global variable, you create a single instance of the class and pass it as an argument to other functions or classes that need it, or make it a member variable of a parent class.
• Controlled access: Any part of the code that needs a configuration value can access it through the instance, ensuring that all access goes through a single, controlled point. [2, 3, 6]

Why this is better than global variables

• Reduces scope: It keeps configuration data out of the global namespace, avoiding potential conflicts and making it clear which part of the program is using which configuration setting.
• Improves readability and maintainability: It's easier to find and understand how configuration data is being used because it's all in one place.
• Improves testability: You can easily swap out the instance in a test environment to provide different settings, rather than trying to manipulate global variables.
• Prevents unintended side effects: Without a single manager, different parts of the code could modify the same global variable in unexpected ways, leading to bugs that are hard to trace.
• Promotes modularity: It encourages you to pass data around explicitly (e.g., as arguments to functions), making dependencies clearer. [2, 3, 4, 6, 7]

AI responses may include mistakes.

[1] https://www.mathworks.com/help/ecoder/ug/optimize-global-variable-usage.html
[2] http://c2.com/cgi/wiki?GlobalVariablesAreBad
[3] https://realpython.com/python-use-global-variable-in-function/
[4] https://www.baeldung.com/cs/global-variables
[5] https://www.codeproject.com/articles/Cracking-the-Mysteries-of-NET-2-0-Configuration
[6] https://www.bbc.co.uk/bitesize/guides/z2q6hyc/revision/3
[7] https://www.linkedin.com/pulse/deep-dive-global-variables-uipath-ashok-karale-5vvof

[ForrestErickson]

Library, configmanage

Another question to an AI
Q

configmanager for Arduino globals

A

For managing global configurations in Arduino projects, the library is a popular choice, particularly for ESP8266 and ESP32 microcontrollers, due to its ability to handle persistent storage and web-based configuration. A key aspect of managing global configuration effectively involves storing settings in non-volatile memory (like EEPROM or SPIFFS) rather than relying solely on standard global variables, which are lost on reset. [1, 2, 3, 4, 5]
Using the Library (ESP8266/ESP32) The library simplifies storing configuration data in a structured way (often using a and JSON for serialization) and managing it through a web interface. [1, 6]
Key Steps:

1. Include the library and create a configuration structure:
2. Initialize the manager in : The library provides methods to define parameters and manage the configuration lifecycle, including loading from persistent storage and handling web-based updates.
3. Run the manager's loop: [1, 7, 8, 9, 10]

Alternative: Manual EEPROM Management For standard Arduinos or simpler projects, you can manually manage configurations using the built-in library. This involves defining a to hold your settings and using EEPROM functions to read/write the entire structure. [2, 11]
Key Concepts:

• Define a : Organize all your global settings into a single for easy reading and writing to memory as a block.
• Use a version identifier: Include a "version" or "signature" field in your to verify if the data in EEPROM is valid and has the expected format.
• Read/Write functions: Implement functions to read the from EEPROM in and write it back when settings change. [2]

General Best Practices Regardless of the method used, adhering to general software engineering principles is important:

• Minimize non-constant globals: Only use global variables when necessary. For data that doesn't need to persist or be accessed everywhere, use local variables and pass them as parameters or references to functions.
• Encapsulation: Consider using a single global configuration object (or instance of a config class) with clearly defined access points to manage and centralize configuration access, which helps with debugging and organization.
• Fail-fast: Implement checks (like the version identifier in the EEPROM example) to ensure configuration data is valid at startup, allowing you to use default settings if corrupted. [2, 8, 12, 13, 14]

AI responses may include mistakes.

[1] https://github.com/nrwiersma/ConfigManager
[2] https://www.norwegiancreations.com/2017/09/how-to-load-and-save-configurations-on-an-arduino/
[3] https://docs.arduino.cc/learn/programming/eeprom-guide
[4] https://www.vitrana.com/products/config-manager/
[5] https://www.industrialshields.com/blog/arduino-industrial-1/storing-the-mac-of-your-plc-arduino-in-the-eeprom-non-volatile-memory-174
[6] https://forum.arduino.cc/t/best-practices-for-managing-configurations-in-arduino-projects-using-json-or-alternative-approaches/1296617
[7] https://registry.platformio.org/libraries/snakeye/WiFiConfig
[8] https://www.reddit.com/r/arduino/comments/ws1psj/global_variables_arent_your_friend/
[9] https://plugins.jetbrains.com/docs/intellij/run-configurations.html
[10] https://github.com/n-elia/MAX30102-MicroPython-driver
[11] https://www.digikey.cz/en/maker/blogs/2021/how-to-permanently-store-data-on-an-arduinos-built-in-eeprom
[12] https://www.reddit.com/r/arduino/comments/ws1psj/global_variables_arent_your_friend/
[13] https://forum.arduino.cc/t/global-variables-in-a-library/586121
[14] https://www.reddit.com/r/arduino/comments/takc5h/code_structure_best_practices/

Library Manager Hits On "ConfigManager"