• https://iies.in/blog/debugging-in-c-tips-and-techniques-for-efficient-coding/
• https://stackoverflow.com/questions/31665240/best-practices-to-embed-c-debug-code-printfs-in-your-codebase
• https://cs.brown.edu/courses/csci1310/2020/assign/labs/lab1.html
• https://www.cs.yale.edu/homes/aspnes/pinewiki/C(2f)Debugging.html?highlight=(CategoryProgrammingNotes)

Writing C code and handling errors effectively is crucial for developing robust applications. Some tips to help you with both:

Writing C Code

1. Understand the Basics:
   • Make sure you have a solid understanding of C's syntax, data types, and control structures. Familiarize yourself with pointers, arrays, and functions.
2. Write Modular Code:
   • Break your code into functions that perform specific tasks. This makes your code easier to read, debug, and maintain.
3. Use Meaningful Variable and Function Names:
   • Choose descriptive names for your variables and functions to make your code more readable and self-documenting.
4. Comment Your Code:
   • Use comments to explain complex logic and important sections of your code. However, avoid over-commenting; your code should be as self-explanatory as possible.
5. Follow Consistent Coding Conventions:
   • Stick to a consistent style guide for indentation, naming conventions, and bracket placement. This improves readability and maintainability.
6. Optimize for Performance:
   • Be aware of the performance implications of your code. Avoid unnecessary computations and understand the complexity of your algorithms.
7. Use Standard Libraries:
   • Leverage C standard libraries for common tasks like I/O, string manipulation, and memory management. This helps avoid reinventing the wheel.
8. Keep Code Portable:
   • Write code that adheres to the ANSI C standard to ensure portability across different compilers and platforms.

Error Handling in C

1. Check Return Values:

   • Many C functions return a value that indicates success or failure. Always check these return values and handle errors appropriately.

   FILE *file = fopen("example.txt", "r");
   if (file == NULL) {
       perror("Error opening file");
       return 1;
   }
   
   

2. Use errno:

   • The global variable errno is set by system calls and some library functions to indicate the error type. Use it with the perror() function or strerror() to get a human-readable error message.

   if (some_function() == -1) {
       perror("some_function failed");
   }
   
   

3. Handle Memory Allocation Failures:

   • When using functions like malloc() or calloc(), always check if the returned pointer is NULL to handle memory allocation failures.

   int *arr = malloc(sizeof(int) * size);
   if (arr == NULL) {
       fprintf(stderr, "Memory allocation failed\\\\n");
       return 1;
   }
   
   

4. Validate Input:

   • Always validate user input and function parameters to ensure they are within expected ranges and formats. This helps prevent unexpected behavior and security vulnerabilities.

   if (input < 0 || input > MAX_VALUE) {
       fprintf(stderr, "Input out of range\\\\n");
       return 1;
   }
   
   

5. Use Assertions for Debugging:

   • Use assert() to check assumptions and invariants in your code during development. This helps catch bugs early.

   #include <assert.h>
   
   void process(int *data) {
       assert(data != NULL);
       // Process data
   }