He dropped out of college but eventually worked as an engineer at IBM and has gone on to roles at many other companies, doing everything from software architecture to management. He runs CodeTV, a Bravo-style reality TV channel for developers.

We talk about:

• Jason's winding path into development from building websites for bands

• Teaching yourself programming by chasing your curiosity

• How in-person events gives you tacit knowledge that makes you a better engineer

• How a having broad range of skills ultimately helps you build better projects

Thanks to the 11,384 kind folks who support freeCodeCamp through a monthly donation. You can join these chill human beings and help our charity's mission by going to donate.freecodecamp.org

You can watch the interview on YouTube:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Links we talk about during our conversation:

• CodeTV: https://codetv.dev/

• The CodeTV YouTube channel: https://www.youtube.com/channel/UCnty0z0pNRDgnuoirYXnC5A

• Jason's website: https://jason.energy/

Ryan dropped out of college and worked as a musician and violin instructor. He spent 5 years teaching himself how to program before getting freelance gigs, and ultimately landing developer jobs.

We talk about:

• Life as a broke musician

• Teaching yourself to code while working full-time

• How Ryan had to move back in with his parents after a divorce

• His 5-year journey to his first developer job

Also, I want to thank the 11,384 kind people who support our charity each month, and who make this podcast possible. You can join them and support our mission at: https://www.freecodecamp.org/donate

You can watch the interview on YouTube:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Links we talk about during our conversation:

Ryan's podcast, Web Dev Dialogues: https://www.webdevdialogues.com/episodes

Ryan's website: https://www.ryanfurrer.com

A freeCodeCamp course on the Astro front end development framework taught by freeCodeCamp podcast guest James Q Quick: https://www.freecodecamp.org/news/learn-the-astro-web-framework/

More Francesco has published courses on learning Docker and the Rust programming language.

We talk about:

• How Francesco worked as a volleyball coach until we was 32, before getting serious about coding

• Francesco's work on coding satellites

• How he's given dozens of talks about emerging tools at major tech conferences

• How he creates tech tutorials even though he's a proud introvert who has to put himself out there

You can watch the interview on the freeCodeCamp YouTube channel.

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

A huge thanks to the 11,384 kind folks who support freeCodeCamp through a monthly donation. You can join these chill human beings and help our mission by going to https://www.freecodecamp.org/donate

Links we talk about during our conversation:

• Francesco's YouTube channel: https://www.youtube.com/@francescociulla

• Francesco's upcoming book on Rust: https://mybook.to/YJI6DI

• Francesco's personal website and all his links: https://www.francescociulla.com

A buffer overflow happens when a program writes more data into a buffer than it was allocated, leading to memory corruption, crashes, or even security vulnerabilities. A buffer corruption occurs when unintended modifications overwrite unread data or modify memory in unexpected ways.

In safety-critical systems like cars, medical devices, and spacecraft, buffer overflows can cause life-threatening failures. Unlike simple software bugs, buffer overflows are unpredictable and depend on the state of the system, making them difficult to diagnose and debug.

To prevent these issues, it's important to understand how buffer overflows and corruptions occur, and how to detect and fix them.

Article Scope

In this article, you will learn:

1. What buffers, buffer overflows, and corruptions are. I’ll give you a beginner-friendly explanation with real-world examples.

2. How to debug buffer overflows. You’ll learn how to use tools like GDB, LLDB, and memory maps to find memory corruption.

3. How to prevent buffer overflows. We’ll cover some best practices like input validation, safe memory handling, and defensive programming.

I’ll also show you some hands-on code examples – simple C programs that demonstrate buffer overflow issues and how to fix them.

What this article doesn’t cover:

1. Security exploits and hacking techniques. We’ll focus on preventing accidental overflows, not hacking-related buffer overflows.

2. Operating system-specific issues. This guide is for embedded systems, not general-purpose computers or servers.

3. Advanced RTOS memory management. While we discuss interrupt-driven overflows, we won’t dive deep into real-time operating system (RTOS) concepts.

Now that you know what this article covers (and what it doesn’t), let’s go over the skills that will help you get the most out of it.

Prerequisites

This article is designed for developers who have some experience with C programming and want to understand how to debug and prevent buffer overflows in embedded systems. Still, beginners can follow along, as I’ll explain key concepts in a clear and structured way.

Before reading, it helps if you know:

1. Basic C programming.

2. How memory works – the difference between stack, heap, and global variables.

3. Basic debugging concepts – if you’ve used a debugger like GDB or LLDB, that’s a plus, but not required.

4. What embedded systems are – a basic idea of how microcontrollers store and manage memory.

Even if you’re not familiar with these topics, this guide will walk you through them in an easy-to-understand way.

Before you dive into buffer overflows, debugging, and prevention, let’s take a step back and understand what a buffer is and why it’s important in embedded systems. Buffers play a crucial role in managing data flow between hardware and software but when handled incorrectly, they can lead to serious software failures.

Table of Contents

• What is a Buffer, and How Does it Work?

• What is a Buffer Overflow?

• Common Causes of Buffer Overflows and Corruption

• Consequences of Buffer Overflows

• How to Debug Buffer Overflows

• How to Prevent Buffer Overflows

• Conclusion

What is a Buffer, and How Does it Work?

A buffer is a contiguous block of memory used to temporarily store data before it is processed. Buffers are commonly used in two scenarios:

1. Data accumulation: When the system needs to collect a certain amount of data before processing.

2. Rate matching: When the data producer generates data faster than the data consumer can process it.

Buffers are typically implemented as arrays in C, where elements are indexed from 0 to N-1 (where N is the buffer size).

Let’s look at an example of a buffer in a sensor system.

Consider a system with a sensor task that generates data at 400 Hz (400 samples per second or 1 sample every 2.5 ms). But the data processor (consumer) operates at only 100 Hz (100 samples per second or 1 sample every 10 ms). Since the consumer task is slower than the producer, we need a buffer to store incoming data until it is processed.

To determine the buffer size, we calculate:

Buffer Size = Time to consume 1 sample / Time to generate 1 sample = 10 ms/ 2.5 ms = 4

This means the buffer must hold at least 4 samples at a time to avoid data loss.

Once the buffer reaches capacity, there are several strategies to decide which data gets passed to the consumer task:

1. Max/min sampling: Use the maximum or minimum value in the buffer.

2. Averaging: Compute the average of all values in the buffer.

3. Random access: Pick a sample from a specific location (for example, the most recent or the first).

In real-world applications, it’s beneficial to use circular buffers or double buffering to prevent data corruption.

• Circular buffer approach: A circular buffer (also called a ring buffer) continuously wraps around when it reaches the end, ensuring old data is overwritten safely without exceeding memory boundaries. The buffer size should be multiplied by 2 (4 × 2 = 8) to hold 8 samples. This allows the consumer task to process 4 samples while the next 4 samples are being filled, preventing data overwrites.

• Double buffer approach: Double buffering is useful when data loss is unacceptable. It allows continuous data capture while the processor is busy handling previous data. A second buffer of the same size is added. When the first buffer is full, the write pointer switches to the second buffer, allowing the consumer task to process data from the first buffer while the second buffer is being filled. This prevents data overwrites and ensures a continuous data flow.

Buffers help manage data efficiently, but what happens when they are mismanaged? This is where buffer overflows and corruptions come into play.

What is a Buffer Overflow?

A buffer overflow occurs when a program writes more data into a buffer than it was allocated, causing unintended memory corruption. This can lead to unpredictable behavior, ranging from minor bugs to critical system failures.

To understand buffer overflow, let's use a simple analogy. Imagine a jug with a tap near the bottom. The jug represents a buffer, while the tap controls how much liquid (data) is consumed.

The jug is designed to hold a fixed amount of liquid. As long as water flows into the jug at the same rate or slower than it flows out, everything works fine. But if water flows in faster than it flows out, the jug will eventually overflow.

Similarly, in software, if data enters a buffer faster than it is processed, it exceeds the allocated memory space, causing a buffer overflow. In the case of a circular buffer, this can cause the write pointer to wrap around and overwrite unread data, leading to buffer corruption.

Buffer Overflows in Software

Unlike the jug, where water simply spills over, a buffer overflow in software overwrites adjacent memory locations. This can cause a variety of hard-to-diagnose issues, including:

1. Corrupting other data stored nearby.

2. Altering program execution, leading to crashes.

3. Security vulnerabilities, where attackers exploit overflows to inject malicious code.

When a buffer overflow occurs, data can overwrite variables, function pointers, or even return addresses, depending on where the buffer is allocated.

Buffer overflows can occur in different memory regions:

1. Buffer overflows in global/static memory (.bss / .data sections)

   • These occur when global or static variables exceed their allocated size.

   • The overflow can corrupt adjacent variables, leading to unexpected behavior in other modules.

   • Debugging is easier because memory addresses are fixed at compile time unless the compiler optimizes them. Map files provide a memory layout of variables during the compilation and linking.

2. Stack-based buffer overflow (more predictable, easier to debug):

   • Happens when a buffer is allocated in the stack (for example, local variables inside functions).

   • Overflowing the stack can affect adjacent local variables or return addresses, potentially crashing the program.

   • In embedded systems with small stack sizes, this often leads to a crash or execution of unintended code.

3. Heap-based buffer overflow (harder to debug):

   • Happens when a buffer is dynamically allocated in the heap (for example, using malloc() in C).

   • Overflowing a heap buffer can corrupt adjacent dynamically allocated objects or heap management structures.

   • Debugging is harder because heap memory is allocated dynamically at runtime, causing memory locations to vary.

Buffer Overflow vs Buffer Corruption

Buffer overflow and buffer corruption are of course related, but refer to different situations.

A buffer overflow happens when data is written beyond the allocated buffer size, leading to memory corruption, unpredictable behavior, or system crashes.

A buffer corruption happens when unintended data modifications result in unexpected software failures, even if the write remains within buffer boundaries.

Both issues typically result from poor write pointer management, lack of boundary checks, and unexpected system behavior.

Now that we've covered what a buffer overflow is and how it can overwrite memory, let’s take a closer look at how these issues affect embedded systems.

In the next section, we’ll explore how buffer overflows and corruption happen in real-world embedded systems and break down common causes, including pointer mismanagement and boundary violations.

Common Causes of Buffer Overflows and Corruption

Embedded systems use buffers to store data from sensors, communication interfaces (like UART (Universal Asynchronous Receiver-Transmitter), SPI (Serial Peripheral Interface), I2C (Inter-integrated Circuit), and real-time tasks. These buffers are often statically allocated to avoid memory fragmentation, and many implementations use circular (ring) buffers to efficiently handle continuous data streams.

Here are three common scenarios where buffer overflows or corruptions occur in embedded systems:

Writing Data Larger Than the Available Space

Issue: The software writes incoming data to the buffer without checking if there is enough space.

Example: Imagine a 100-byte buffer to store sensor data. The buffer receives variable-sized packets. If an incoming packet is larger than the remaining space, it will overwrite adjacent memory, leading to corruption.

So why does this happen?

• Some embedded designs increment the write pointer after copying data, making it too late to prevent overflow.

• Many low-level memory functions (memcpy, strcpy, etc.) do not check buffer boundaries, leading to unintended writes.

• Without proper bound checking, a large write can exceed the buffer size and corrupt nearby memory.

Here’s a code sample to demonstrate buffer overflow in a .bss / .data section:

  #include <stdint.h>
  #include <stdio.h>
  #include <string.h>

  #define BUFFER_SIZE 300

  static uint16_t sample_count = 0;
  static uint8_t buffer[BUFFER_SIZE] = {0};

  // Function to simulate a buffer overflow scenario
  void updateBufferWithData(uint8_t *data, uint16_t size)
  {
      // Simulating a buffer overflow: No boundary check!
      printf("Attempting to write %d bytes at position %d...\n", size, sample_count);

      // Deliberate buffer overflow for demonstration
      if (sample_count + size > BUFFER_SIZE)
      {
          printf("WARNING: Buffer Overflow Occurred! Writing beyond allocated memory!\n");
      }

      // Copy data (unsafe, can cause overflow)
      memcpy(&buffer[sample_count], data, size);

      // Increment sample count (incorrectly, leading to wraparound issues)
      sample_count += size;
  }

  int main()
  {   
      // Save 1 byte to buffer
      uint8_t data_to_buffer = 10;
      updateBufferWithData(&data_to_buffer, 1);

      // Save an array of 20 bytes to buffer
      uint8_t data_to_buffer_1[20] = {5};
      updateBufferWithData(data_to_buffer_1, sizeof(data_to_buffer_1));

      // Intentional buffer overflow: Save an array of 50 x 8 bytes (400 bytes)
      uint64_t data_to_buffer_2[50] = {7};
      updateBufferWithData((uint8_t*)data_to_buffer_2, sizeof(data_to_buffer_2));

      return 0;
  }

Interrupt-Driven Overflows (Real-time Systems)

Issue: The interrupt service routine (ISR) may write data faster than the main task can process, leading to buffer corruption or buffer overflow if the write pointer is not properly managed.

Example: Imagine a sensor ISR that writes incoming data into a buffer every time a new reading arrives. Meanwhile, a low-priority processing task reads and processes the data.

What can go wrong?

• If the ISR triggers too frequently (due to a misbehaving sensor or high interrupt priority), the buffer may fill up faster than the processing task can keep up.

• This can result in one of two failures:

  1. Buffer Corruption: The ISR overwrites unread data, leading to loss of information.

  2. Buffer Overflow: The ISR exceeds buffer boundaries, causing memory corruption or system crashes.

So why does this happen?

• In real-time embedded systems, ISR execution preempts lower-priority tasks.

• If the processing task doesn't not get enough CPU time, the buffer may become overwritten or overflow beyond its allocated scope.

System State Changes & Buffer Corruption

Issue: The system may unexpectedly reset, enter low-power mode, or changes operating state, leaving the buffer write pointers in an inconsistent state. This can result in buffer corruption (stale or incorrect data) or buffer overflow (writing past the buffer’s limits.

Example Scenarios:

1. Low-power wake-up issue (Buffer Overflow risk): Some embedded systems enter deep sleep to conserve energy. Upon waking up, if the buffer write pointer is not correctly reinitialized, it may point outside buffer boundaries, leading to buffer overflow and unintended memory corruption.

2. Unexpected mode transitions: If a sensor task is writing data and the system suddenly switches modes, the buffer states and pointers may not be cleaned up. The next time the sensor task runs, it may continue writing without clearing previous data. This can cause undefined behavior due to presence of stale data.

Now that you understand how buffer overflows and corruptions happen, let’s examine their consequences in embedded systems ranging from incorrect sensor readings to complete system failures, making debugging and prevention critical.

Consequences of Buffer Overflows

Buffer overflows can be catastrophic in embedded systems, leading to system crashes, data corruption, and unpredictable behavior. Unlike general-purpose computers, many embedded devices lack memory protection, making them particularly vulnerable to buffer overflows.

A buffer overflow can corrupt two critical types of memory:

1. Data Variables Corruption

A buffer overflow can overwrite data variables, corrupting the inputs for other software modules. This can cause unexpected behavior or even system crashes if critical parameters are modified.

For example, a buffer overflow could accidentally overwrite a sensor calibration value stored in memory. As a result, the system would start using incorrect sensor readings, leading to faulty operation and potentially unsafe conditions.

2. Function Pointer Corruption

In embedded systems, function pointers are often used for interrupt handlers, callback functions, and RTOS task scheduling. If a buffer overflow corrupts a function pointer, the system may execute unintended instructions, leading to a crash or unexpected behavior.

As an example, a function pointer controlling motor speed regulation could be overwritten. Instead of executing the correct function, the system would jump to a random memory address, causing a system fault or erratic motor behavior.

Buffer overflows are among the hardest bugs to identify and fix because their effects depend on which data is corrupted and the values it contains. A buffer overflow can affect memory in different ways:

• If a buffer overflow corrupts unused memory, the system may seem fine during testing, making the issue harder to detect.

• if a buffer overflow alters critical data variables, it can cause hidden logic errors that cause unpredictable behavior.

• If a buffer overflow corrupts function pointers, it may crash immediately, making the problem easier to identify.

During development, if tests focus only on detecting crashes, they may overlook silent memory corruption caused by a buffer overflow. In real-world deployments, new use cases not covered in testing can trigger previously undetected buffer overflow issues, leading to unpredictable failures.

Buffer overflows can cause a chain reaction, where one overflow leads to another overflow or buffer corruption, resulting in widespread system failures. So how does this happen?

1. A buffer overflow corrupts a critical variable (for example, a timer interval).

2. The corrupted variable disrupts another module (for example, triggers the timer interrupt too frequently, causing it to push more data into a buffer than intended.).

3. This increased interrupt frequency forces a sensor task to write data faster than intended, eventually causing another buffer overflow or corruption by overwriting unread data.

This chain reaction can spread across multiple software modules, making debugging nearly impossible. In real-word applications, buffer overflows in embedded systems can be life-threatening:

• In cars: A buffer overflow in an ECU (Electronic Control Unit) could cause brake failure or unintended acceleration.

• In a spacecraft: A memory corruption issue could disable navigation systems, leading to mission failure.

Now that we’ve seen how buffer overflows can corrupt memory, disrupt system behavior, and even cause critical failures, the next step is understanding how to detect and fix them before they lead to serious issues.

How to Debug Buffer Overflows

Debugging buffer overflows in embedded systems can be complex, as their effects range from immediate crashes to silent data corruption, making them difficult to trace. A buffer overflow can cause either:

1. A system crash, which is easier to detect since it halts execution or forces a system reboot.

2. Unexpected behavior, which is much harder to debug as it requires tracing how corrupted data affects different modules.

This section focuses on embedded system debugging techniques using memory map files, debuggers (GDB/LLDB), and a structured debugging approach. Let’s look into the debuggers and memory map files.

Memory Map File (.map file)

A memory map file is generated during the linking process. It provides a memory layout of global/static variables, function addresses, and heap/stack locations. It provides a memory layout of Flash and RAM, including:

• Text section (.text): Stores executable code.

• Read-only section (.rodata): Stores constants and string literals.

• BSS section (.bss): Stores uninitialized global and static variables.

• Data section (.data): Stores initialized global and static variables.

• Heap and stack locations, depending on the linker script.

If a buffer overflow corrupts a global variable, the .map file can identify nearby variables that may also be affected, provided the compiler has not optimized the memory allocation. Similarly, if a function pointer is corrupted, the .map file can reveal where it was stored in memory.

Debuggers (GDB & LLDB)

Debugging tools like GDB (GNU Debugger) and LLDB (LLVM Debugger) allow:

• Controlling execution (breakpoints, stepping through code).

• Inspecting variable values and memory addresses.

• Getting backtraces (viewing function calls before a crash).

• Extracting core dumps from microcontrollers for post-mortem analysis.

If the system halts on a crash, a backtrace (bt command in GDB) can reveal which function was executing before failure. If the overflow affects a heap-allocated variable, GDB can inspect heap memory usage to detect corruption.

The Debugging Process

Now, let’s go through a step-by-step debugging process to identify and fix buffer overflows. Once a crash or unexpected behavior occurs, follow these techniques to trace the root cause:

Step 1: Identify the misbehaving module

If the system crashes, use GDB or LLDB backtrace (bt command) to locate the last executed function. If the system behaves unexpectedly, determine which software module controls the affected functionality.

Step 2: Analyze inputs and outputs of the module

Every function or module has inputs and outputs. Create a truth table listing expected outputs for all possible inputs. Check if the unexpected behavior matches any undefined input combination, which may indicate corruption.

Step 3: Locate memory corruption using address analysis

If a variable shows incorrect values, determine its physical memory location. Depending on where the variable is stored:

1. Global/static variables (.bss / .data): Look up the memory map file for nearby buffers.

2. Heap variables: Snapshot heap allocations using GDB.

   Here’s an example of using GDB to find corrupted variables:

    (gdb) print &my_variable  # Get memory address of the variable
    $1 = (int *) 0x20001000
    (gdb) x/10x 0x20001000   # Examine memory near this address, Display 10 memory words in hexadecimal format starting from 0x20001000
   

Step 4: Identify the overflowing buffer

If a buffer is located just before the corrupted variable, inspect its usage in the code. Review all possible code paths that write to the buffer. Check if any design limitations could cause an overflow under a specific use cases.

Step 5: Fix the root cause

If the buffer overflow happened due to missing bounds checks, add proper input validation to prevent it. Buffer design should enforce strict memory limits. The module should implement strict boundary checks for all inputs and maintain a consistent state.

In addition to GDB/LLDB, you can also use techniques like hardware tracing and fault injection to simulate buffer overflows and observe system behavior in real-time.

While debugging helps identify and fix buffer overflows, prevention is always the best approach. Let’s explore techniques that can help avoid buffer overflows altogether.

How to Prevent Buffer Overflows

You can often prevent buffer overflows through good software design, defensive programming, hardware protections, and rigorous testing. Embedded systems, unlike general-purpose computers, often lack memory protection mechanisms, which means that buffer overflow prevention critical for system reliability and security.

Here are some key techniques to help prevent buffer overflows:

Defensive Programming

Defensive programming helps minimize buffer overflow risks by ensuring all inputs are validated and unexpected conditions are handled safely.

First, it’s crucial to validate input size before writing to a buffer. Always check the write index by adding the size of data to be written prior to writing data to make sure more data is not written than the available buffer space.

Then you’ll want to make sure you have proper error handling and fail-safe mechanisms in place. If an input is invalid, halt execution, log the error, or switch to a safe state. Also, functions should indicate success/failure with helpful error codes to prevent misuse.

Sample Code:

   #include <stdint.h>
   #include <string.h>
   #include <stdbool.h>
   #include <stdio.h>

   #define BUFFER_SIZE 300

   static uint16_t sample_count = 0;
   static uint8_t buffer[BUFFER_SIZE] = {0};

   typedef enum
   {
       SUCCESS = 0,
       NOT_ENOUGH_SPACE = 1,
       DATA_IS_INVALID = 2,
   } buffer_err_code_e;


   buffer_err_code_e updateBufferWithData(uint8_t *data, uint16_t size)
   {
       if (data == NULL || size == 0 || size > BUFFER_SIZE)  
       {
           return DATA_IS_INVALID; // Invalid input size
       }

       uint16_t available_space = BUFFER_SIZE - sample_count;
       bool can_write = (available_space >= size) ? true : false;

       if (!can_write)  
       {
           return NOT_ENOUGH_SPACE;
       }

       // Copy data safely
       memcpy(&buffer[sample_count], data, size);
       sample_count += size;

       return SUCCESS;
   }

   int main()
   {   
       buffer_err_code_e ret;

       // Save 1 byte to buffer
       uint8_t data_to_buffer = 10;
       ret = updateBufferWithData(&data_to_buffer, sizeof(data_to_buffer));
       if (ret)  
       {
           printf("Buffer update didn't succeed, Err:%d\n", ret);
       }

       // Save an array of 20 bytes to buffer
       uint8_t data_to_buffer_1[20] = {5};
       ret = updateBufferWithData(data_to_buffer_1, sizeof(data_to_buffer_1));
       if (ret)  
       {
           printf("Buffer update didn't succeed, Err:%d\n", ret);
       }

       // Save an array of 50 x 8 bytes, Intentional buffer overflow
       uint64_t data_to_buffer_2[50] = {7};
       ret = updateBufferWithData((uint8_t*)data_to_buffer_2, sizeof(data_to_buffer_2));  
       if (ret)  
       {
           printf("Buffer update didn't succeed, Err:%d\n", ret);
       }

       return 0;
   }

Choosing the Right Buffer Design And Size

Some buffer designs handle overflow better than others. Choosing the correct buffer type and size for the application reduces the risk of corruption.

• Circular Buffers (Ring Buffers) prevent out-of-bounds writes by wrapping around. They overwrite the oldest data instead of corrupting memory. These are useful for real-time streaming data (for example, UART, sensor readings). This approach is ideal for applications where data loss is unacceptable.

• Ping-Pong Buffers (Double Buffers) use two buffers. One buffer fills up with data. Then, once it’s full, it switches to the second buffer while the first one is processed. This approach is beneficial for application that have strict requirements on no data loss. The buffer design should be based on the speed of write and read tasks.

Hardware Protection

Memory Protection Unit (MPU)

An MPU (Memory Protection Unit) helps detect unauthorized memory accesses, including buffer overflows, by restricting which regions of memory can be written to. It prevents buffer overflows from modifying critical memory regions and triggers a MemManage Fault if a process attemps to write outside an allowed region.

But keep in mind that, an MPU does not prevent buffer overflows – it only detects and stops execution when they occur. Not all microcontrollers have an MPU, and some low-end MCUs lack hardware protection, making software-based safeguards even more critical.

Modern C compilers provide several flags to identify memory errors at compile-time:

1. -Wall -Wextra: Enables useful warnings

2. -Warray-bounds: Detects out-of-bounds array access when the array size is known at compile-time

3. -Wstringop-overflow: Warns about possible overflows in string functions like memcpy and strcpy.

Testing and Validation

Testing helps detect buffer overflows before deployment, reducing the risk of field failures. Unit testing each function independently with valid inputs, boundary cases, and invalid inputs helps detect buffer-related issues early. Automated testing involves feeding random and invalid inputs into the system to uncover crashes and unexpected behavior. Static Analysis Tools like Coverity, Clang Static Analyzer help detect buffer overflows before runtime. Run real-world inputs on embedded hardware to detect issues.

Now that we've explored how to identify, debug, and prevent buffer overflows, it’s clear that these vulnerabilities pose a significant threat to embedded systems. From silent data corruption to catastrophic system failures, the consequences can be severe.

But with the right debugging tools, systematic analysis, and preventive techniques, you can effectively either prevent or mitigate buffer overflows in your systems.

Conclusion

Buffer overflows and corruption are major challenges in embedded systems, leading to crashes, unpredictable behavior, and security risks. Debugging these issues is difficult because their symptoms vary based on system state, requiring systematic analysis using memory map files, GDB/LLDB, and structured debugging approaches.

In this article, we explored:

• The causes and consequences of buffer overflows and corruptions

• How to debug buffer overflows using memory analysis and debugging tools

• Best practices for prevention

Buffer overflow prevention requires a multi-layered approach:

1. Follow a structured software design process to identify risks early.

2. Apply defensive programming principles to validate inputs and handle errors gracefully.

3. Use hardware-based protections like MPUs where available.

4. Enable compiler flags that help identify memory errors.

5. Test extensively, unit testing, automated testing, and code reviews help catch vulnerabilities early.

By implementing these best practices, you can minimize the risk of buffer overflows in embedded systems, improving reliability and security.

In embedded systems, where reliability and safety are critical, preventing buffer overflows is not just a best practice, it is a necessity. A single buffer overflow can compromise an entire system. Defensive programming, rigorous testing, and hardware protections are essential for building secure and robust embedded applications.

Jesse has created tons of tutorials over the years on YouTube and on freeCodeCamp. We talk about his coding journey, how the field has changed over the few years, and how hype has distorted peoples' perception of getting into code.

We talk about:

• Growing up in a one stop light town

• Teaching himself to code for free using freeCodeCamp

• How he created YouTube tutorials to inspire his kids, then got quite good at it

• How Jesse's early interest in Web3 lead him to needing to "dig himself out of the grave" of being "the NFT tutorial guy"

Support also comes from the 11,384 kind folks who support freeCodeCamp through a monthly donation. Join these kind folks and help our mission by going to https://www.freecodecamp.org/donate

You can watch the interview on YouTube:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Links we talk about during our conversation:

• Jesse's tutorials on freeCodeCamp: https://www.freecodecamp.org/news/author/codeSTACKr/

• Jesse's course on how to set up and configure the VS Code editor: https://www.youtube.com/watch?v=fJEbVCrEMSE

Anjana was an English teacher who studied computational linguistics, and found building software to be more fun than actual research.

She's worked at ton of tech companies and has freelance clients. She shares some excellent tips on learning new skills and avoiding burnout.

We talk about:

• How Anjana taught herself to code in her 30s

• Being an American dev working in Europe

• Stress, burnout, and how she gets by

• How skills from your previous non-developer career can help differentiate you as a developer

You can watch the interview on YouTube:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Support comes from the 11,243 kind folks who support freeCodeCamp through a monthly donation. Join these kind folks and help our mission by going to https://www.freecodecamp.org/donate

Links we talk about during our conversation:

• "How to be the ideal newb" article: https://jvns.ca/blog/good-questions/

• "Burnout: The Secret to Unlocking the Stress Cycle" book that Anjana mentions: https://www.amazon.com/Burnout-Secret-Unlocking-Stress-Cycle/dp/198481706X

• Anjana's website: https://anjana.dev/

We talk about:

• How Vaughn struggled with high school and joined the Navy

• How he learned Japanese so he could work as a personal trainer in Japan

• How he learned coding using freeCodeCamp as a way to make more time and more money

• His pragmatic approach for teaching himself new skills for free

You can watch the interview on YouTube:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Links we talk about during our conversation:

• Vaughn's YouTube channel and his approach to pursuing multiple skills in tandem: https://www.youtube.com/watch?v=wTnsjmsgJS8

• Vaughn on Instagram where he posts guitar: https://www.instagram.com/vaughngene/

Julia taught herself to code in her 30s using freeCodeCamp.

We talk about:

• Julia's coding journey from poker dealer to self-taught software engineer

• How she creates tutorials in Japanese

• Her passion for making software easier to use for everyone

• Working remotely at a big European software consultancy

You can watch the interview on YouTube:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Links we talk about during our conversation:

• Julia's website: https://www.juliaundeutsch.com/

• Movie trailer for the 1999 Clive Owen movie "Croupier" that Quincy mentions: https://www.youtube.com/watch?v=LDWzeq5QGiA

We talk about:

• How she grew up a first generation American and public school kid in Milwaukee

• How her love of robotics helped her get into Stanford

• How freeCodeCamp served as a key resource to build her developer chops

• The near future of humanoid robots, self-driving cars, and human-like AI agents in games

Support for this podcast comes from a grant from Wix Studio. Wix Studio provides developers tools to rapidly build websites with everything out-of-the-box, then extend, replace, and break boundaries with code. Learn more at https://wixstudio.com.

Support also comes from the 11,043 kind folks who support freeCodeCamp through a monthly donation. Join these kind folks and help our mission by going to https://www.freecodecamp.org/donate

You can watch the interview on YouTube.

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Links we talk about during our conversation:

• Peggy's GameDev company, Ego AI: https://www.egoai.com/

• Quincy's interview with hardware engineer Bruno Haid that he mentions toward the end of this episode: https://www.freecodecamp.org/news/podcast-hardware-engineering-bruno-haid/

Rishab grew up in India and moved to Canada for school. But he couldn't afford to finish. He resorted to delivering pizzas and working at a gas station. But he worked hard to teach himself how to code and how to build cloud infrastructure, and eventually got a job Google.

We talk about:

• How to teach yourself cloud engineering

• Getting repeatedly rejected from FAANG jobs but persisting

• Filling up the Infinity Gauntlet with cloud certifications

• How DevOps and Cloud Engineering are changing

Support for this podcast comes from the 11,043 kind folks who support freeCodeCamp through a monthly donation. Join these kind folks and help our mission by going to https://www.freecodecamp.org/donate

You can watch the podcast on YouTube below:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Links we talk about during our conversation:

• Rishab's Terraform course on freeCodeCamp: https://www.freecodecamp.org/news/how-to-use-terraform-to-deploy-a-site-on-google-cloud-platform/

• Rishab's LangChain LLM deployment course on freeCodeCamp: https://www.freecodecamp.org/news/learn-langchain-for-llm-development/

• Learn to Cloud guide by Rishab and his friend at Microsoft, Gwyn: https://learntocloud.guide/

• Rishab's YouTube channel https://www.youtube.com/@rishabincloud/videos

We talk about:

• Lane’s thoughts on college and computer science degrees

• Back end development and why it resonates with him

• Why he's so enthusiastic about the Go Programming Language

• What he’s learned about how people learn

You can watch the interview on YouTube:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Support comes from the 11,043 kind folks who support freeCodeCamp through a monthly donation. Join these kind folks and help our mission by going to https://www.freecodecamp.org/donate

Quincy mentions the number of engineers graduating every year from Indian and Chinese universities (including computer science majors, which is usually the most popular engineering degree). It's hard to find exact numbers but...

• India: more than 1 million engineering graduates / year

• China: more than 1 million engineering graduates / year

• US: only about 200,000 engineering graduates / year

Links we talk about during our conversation:

• Lane's 4-hour course on how to get a job as a developer: https://www.freecodecamp.org/news/how-to-get-a-developer-job/

• Lane's 5-hour HTTP Networking course: https://www.freecodecamp.org/news/http-networking-protocol-course/

• Lane's SQL for Web Developers course: https://www.freecodecamp.org/news/sql-for-web-devs/

• Lane's freely available books published through freeCodeCamp Press: https://www.freecodecamp.org/news/author/wagslane/

• Khan Academy founder's talk on mastery learning: https://www.youtube.com/watch?v=-MTRxRO5SRA

• The Zone of Proxmial Development education concept: https://en.wikipedia.org/wiki/Zone_of_proximal_development

Did you know that organizations such as freeCodeCamp, Google, and Harvard offer online courses to help you learn software development? And that many of these include free certificates and badges?

To help you choose one that's right for you, I've created a full list.

As avid online learners, my Class Central colleagues and I have completed hundreds of online courses over the years, including many with free certificates, as you can see in the collage below.

In 2025, free certificates have become rarer. But if you know where to look, there is still an abundance of free certificates available online for learning software development.

Some of the free certificates earned by the Class Central team.

As you likely know, freeCodeCamp offers free certifications. But so do big tech companies and institutions such as Google, Microsoft, and Harvard.

In this article, we bring together all the free certificates and badges that are scattered across the web. In total, the platforms below offer over 900 free certificate courses for learning software development.

I (Dhawal) started Class Central back in 2011, when universities such as Stanford began to offer some of their courses online for free. Since then, the Class Central database has grown to over 250K online courses.

Having written about online education for over a decade, I remember when platforms like Coursera and edX offered free certificates. Then, rather abruptly, free certificates seemed to pretty much disappear.

This inspired us to write a Massive List of Free Certificates and Badges. To our surprise, we discovered there were still thousands of free certificates available online. To date, that article has received 10M views.

In the same vein, this article aims to draw attention to the organizations that continue to support open education in software development by offering free certificate courses. These include:

• Learning platforms — e.g. LinkedIn Learning, CodeSignal, and freeCodeCamp

• Leading universities — e.g. Harvard and the University of Helsinki

• Big tech companies — e.g. Google and IBM.

Please note, Class Central is not involved in running the courses or issuing certificates. This is a dynamic field and you may discover that a course you choose is no longer available, or doesn’t have a free certificate any more. We recommend you always check before starting a course.

freeCodeCamp Free Certifications

Archisha's freeCodeCamp free certificate

freeCodeCamp platform offers thousands of hours of learning content, broken down into certifications on subjects such as web development and data science.

Here are the certifications currently offered, several others are due to be released soon:

• Responsive Web Design Certification

• Front End Development Libraries Certification

• Back End Development and APIs

• Back End Development and APIs (in development) ★★★★★(3)

• Certified Full Stack Developer (in development)

• Relational Database

• JavaScript Certification

• Foundational C# with Microsoft

• Certified Full Stack Developer

• Python

While strictly not developer courses, A2 English for Developers and  B1 English for Developers focuses on vocabulary that is particularly useful for developers. Prepare for real-world interactions by applying English skills in professional and technical settings.

Cisco Free Badges

Cisco Network Academy

Cisco, the IT and networking giant, offers a series of self-paced online courses through its Networking Academy platform; some include free badges for skills learned. Here’s a selection:

• Introduction to Cybersecurity

• NDG Linux Unhatched

• NDG Linux Essentials

• CPA: Programming Essentials in C++

• Introduction to IoT

• Python Essentials 1

You can find the full list of Cisco Networking Academy courses here.

CodeSignal Free Certificates

Pat's free CodeSignal certificate

CodeSignal is a growing platform that offers 2000+ courses and learning paths with free certificates in coding, AI & ML, data science, interview prep, and more. As well as developer and IT certificates, CodeSignal teaches valuable soft skills.

Here’s a selection:

• Introduction to Programming with Python

• Four-Week Coding Interview Prep in Python

• Prompt Engineering for Everyone

• Comprehensive Introduction to Front-End Engineering

• JavaScript Programming for Beginners

• Java Programming for Beginners

• Implementing AI Algorithms from Scratch

• Introduction to Machine Learning with SciKit Learn

• Supercommunicators – Have Conversations that Matter

• Dare to Lead – Unlock Courageous Leadership

You can find more details in our dedicated article, and the full list of CodeSignal Learn courses.

Google Free Certificates and Badges

Pat’s free Google badge

Google has launched several initiatives to teach people skills such as coding, digital marketing, and data analytics. Some offer certificates, some have badges.

Here is a selection of Google’s offerings:

• Introduction to Generative AI

• Introduction to Responsible AI

• Introduction to Image Generation

• Planetary Scale Earth Observation with Google Earth Engine

• Introduction to Large Language Models

• Google Analytics Certification

• Build your first web app with Firebase

• Build apps with Flutter

• Introduction to SQL

• Get data from the internet

• Adapt for different screen sizes

• Kotlin fundamentals

• Develop locally with Firebase

• Make your Android app more accessible

• Build cross-platform apps with Angular

• Jetpack Compose basics

• Site Reliability Engineering: Measuring and Managing Reliability

• Attention Mechanism

• Transformer Models and BERT Model

• Create Image Captioning Models

• Encoder-Decoder Architecture

• Hybrid Cloud Infrastructure Foundations with Anthos

• Preparing for the Google Cloud Professional Data Engineer Exam

• Understanding Google Cloud Security and Operations

• Innovating with Data and Google Cloud

• Infrastructure and Application Modernization with Google Cloud

• Developing a Google SRE Culture

• Managing Change when Moving to Google Cloud

• Deploying SAP on Google Cloud

• The Modern Data Platform and LookML

• Digital Transformation with Google Cloud

• Managing and Securing the Apigee Hybrid API Platform

• Upgrading and Monitoring the Apigee Hybrid API Platform

• Preparing for Your Professional Cloud Security Engineer Journey

• Preparing for Your Associate Cloud Engineer Journey

• Preparing for your Professional Cloud Architect Journey

• Innovating with Data and Google Cloud

• Preparing for Your Professional Cloud Network Engineer Journey

• Design Foundations for Streaming with Google Cloud

• Introduction to Cloud Identity

You can find more details in our dedicated article and here is a complete list of courses by Google.

HackerRank Free Certificates

Manoel’s HackerRank free certificate

HackerRank is a platform for learning algorithms and data structures and preparing for coding interviews, provides skills certifications tests in topics such as problem solving, Python, and JavaScript.

Here are some of the 24 tests you may complete to earn a certificate:

• Problem Solving (Basic) Skills Certification

• Python (Basic) Skills Certification

• Java (Basic) Skills Certification

• C# (Basic) Skills Certification

• JavaScript (Basic) Skills Certification

• SQL (Basic) Skills Certification

• Go (Basic) Skills Certification

• R (Basic) Skills Certification

• Node (Basic) Skills Certification

Harvard Free Certificates

Pat’s Free Harvard CS50 Scratch Certificate

Harvard offers a series of academic online courses exploring various facets of computer science, including programming fundamentals and AI.

Here are Harvard’s current free certificate offerings. Remember that while you need an account with edX to submit the assignments, the free certificate comes directly from CS50.

• Introduction to Computer Science

• Computer Science for Business Professionals

• Introduction to Artificial Intelligence with Python

• Web Programming with Python and JavaScript

• Computer Science for Lawyers

• Introduction to Programming with Python

• Introduction to Programming with Scratch

• Introduction to Cybersecurity

• Introduction to Databases with SQL

• Introduction to Programming with R

You can find more details and how to receive your free certificate in our dedicated article and here is a complete list of courses from Harvard.

Hasso Plattner Institute Free Certificates

Hasso Plattner Institute free courses

The Hasso Plattner Institute offers a range of self-paced courses with free certificates of participation and achievement. Most courses are in German, but some are in English.

Here’s a selection of courses in English:

• Understanding Embeddings for Natural Language Processing

• Data Science Bootcamp

• Introduction to Bayesian Data Analysis

• Introduction to Quantum Computing with Qiskit (with IBM Quantum)

Hugging Face Free Certificates

Hugging Face courses

Hugging Face develops computation tools for building applications using machine learning and offers several courses, some with free certificates.

• Model Context Protocol (MCP)

• AI Agents

• Deep Reinforcement Learning

• Audio

IBM Free Certificates and Badges

The CognitiveClass.ai homepage

IBM’s platform CognitiveClass.ai offers 100+ courses and 10 learning paths in data science, AI, big data, cloud computing, and blockchain. Some courses offer a completion badge or certificate. Check on the Cognitive Class.AI course page for details.

The platform also provides a virtual lab environment allowing users to practice what they’ve learned in the courses.

Here’s a selection:

• Accelerating Deep Learning with GPUs

• Introduction to Open Source

• Text Analytics 101

• Applied Data Science with R

• Big Data Foundations

Pat’s free certificate and badge for Introduction to IBM Storage and Cloud

Some of the 24 free learning paths and 582 free courses from IBM Training have free certificates and badges available from IBM Training or via Credly. Courses are in a range of fields including AI, automation, infrastructure, cloud, security, and more.

Kaggle Free Certificates

Kaggle free certificate courses

Kaggle is an online community for data scientists and aspiring data scientists alike. It offers over 50K public datasets, allowing you to build your own data science projects through Jupyter notebooks, and participate in competitions.

In addition, the platform offers a series of courses to learn the fundamentals of data science. Each leads to a certificate of completion.

• Python

• Intro to SQL

• Advanced SQL

• Intro to Deep Learning

• Data Cleaning

• Time Series

• Computer Vision

• Intro to Machine Learning

• Pandas

• Data Visualization

• Intro to AI Ethics

• Machine Learning Explainability

• Feature Engineering

• Intermediate Machine Learning

• Intro to Game AI and Reinforcement Learning

LinkedIn Learning Courses with Free Certificates

Suparn’s LinkedIn Learning free certificate

LinkedIn Learning, the online learning platform integrated with the LinkedIn professional social network, offers more than a hundred online courses and learning paths that include a free certificate.

Here’s a selection of LinkedIn Learning free certificate courses:

• Programming Foundations: Fundamentals

• Programming Foundations: Beyond the Fundamentals

• Learning Data Analytics: 1 Foundations

• Learning Data Science: Understanding the Basics

• The Cybersecurity Threat Landscape

You can find more details and the full list or free certificates in our dedicated article, and here is a complete list of courses by LinkedIn Learning.

MATLAB Free Certificates

MATLAB free courses

MathWorks, the company behind the MATLAB programming language and software, offers 23 free online courses with certificates through their MATLAB Academy platform.

The courses introduce learners to the MATLAB language and tools — with a focus on machine learning — and MathWorks’ specialized software, such as Simulink. You can find all the details and how to receive your free certificate in our dedicated article.

Here’s a selection:

• MATLAB Onramp

• Machine Learning Onramp

• Reinforcement Learning Onramp

• Signal Processing Onramp

• Stateflow Onramp

• Circuit Simulation Onramp

• Deep Learning Onramp

• Wireless Communications Onramp

• Simscape Onramp

• Optimization Onramp

• App Building Onramp

• Object-Oriented Programming Onramp

• Computer Vision Onramp

• Simulink Onramp

• Control Design Onramp with Simulink

• System Composer Onramp

• Power Systems Simulation Onramp

Semrush Academy Free Certificates

Semrush Academy free courses

Although Semrush is primarily a business and marketing specialist, some of their free certificate courses are relevant for developers and IT professionals:

• On-Page and Technical SEO Course

• Mobile SEO Course with Greg Gifford

• Technical SEO course with Bastian Grimm

• Semrush SEO Crash Course with Brian Dean

University of Helsinki Free Certificates

Pat’s Elements of AI free certificate

The University of Helsinki offers academic online courses through its independent course platform, MOOC.fi, including the following courses which include a free certificate of completion:

• Elements of AI

• Full Stack open

• Java Programming

• Cyber Security Base

• Ethics of AI

upGrad Free Certificates

Suparn’s upGrad free certificate

upGrad is an online learning platform that offers free programs and courses on subjects such as data science, business analytics, and technology.

An e-Certificate of Completion is provided in 30 days after you successfully finish all the modules within your program. Your phone number is required while registering a course so you may receive calls and messages from upGrad.

Here are some of the free programs offered on upGrad:

• Programming with Python: Introduction for Beginners

• Introduction to Natural Language Processing

• Introduction to Data Analysis using Excel

• Introduction to Database Design with MySQL

• Data Science in E-commerce

• Introduction to NFTs

• E-Skills in Healthcare

• Core Java Basics

• Introduction to Blockchain Technology

FutureLearn Free Certificates

Elham’s FutureLearn free certificate

FutureLearn, the European counterpart to Coursera and edX, offers some courses that include a free “digital upgrade” — which, among others, entails a free certificate of completion.

Here’s a list of some of FutureLearn’s free offerings:

• Digital Skills: Digital Skills for Work and Life

• Digital Skills: Digital Marketing

• Digital Skills: Social Media

• Digital Skills: Artificial Intelligence

• Digital Skills: User Experience

• Introduction to Virtual, Augmented and Mixed Reality

• Digital Skills: Reimagine Your Career

• Digital Skills: Mobile

• Digital Skills: Web Analytics

You can find more details in our dedicated article and here is a full list of FutureLearn courses.

Wolfram U Free Certificates

Wolfram U free courses

The Wolfram Language is a powerful programming tool employed in science, engineering, data science, and finance. It combines math, data analysis, and general programming, and forms the core of Wolfram’s popular software, Mathematica. You can find all the details in our dedicated article.

Here is a selection of Wolfram U’s 40+ free certificate courses:

• Full Interactive Course for Introduction to Wolfram Language

• Quick Start to Wolfram Tech Course

• Wolfram Language Programming Proficiency

• Programming Fundamentals of Wolfram Language

• A Guide to Programming Course

• Practical Programming with Wolfram Language

• Wolfram Language Fast Introduction for Programmers Video Series

• Programming and Development in Wolfram Language Instructor Led Course

• Getting Started with Mathematica and Wolfram Language: Wolfram Daily Study Groups

• Wolfram Summer School Lectures: Online Course

• Visual Explorations in Data Science Course

• Multiparadigm Data Science, Interactive Online Video Course

• Introduction to Machine Learning

• Introduction to Neural Networks in Wolfram Language Class

• Data Visualization with Wolfram Language

• Wolfram Language and LLMs Instructor-Led Course

• Computational Xplorations

• Creative Computation, Online Video Course

• Introduction to Notebooks, Interactive Online Video Course

• Notebooks as Instructional Tools—Wolfram U Instructor-Led Course

• Wolfram Notebooks: Building and Sharing Technical Workflows

• Introduction to Image Processing, Interactive Online Video Course

• Signals, Systems and Signal Processing Course

More Free Certificates

If you don’t find what you need here, browse Class Central’s catalog of 250K courses or visit our thematic collections:

• Massive List of Thousands of Free Certificates and Badges

• Stanford Medicine Offers Courses with Free Certificate & CME Credit

• 470+ Hours of Free LinkedIn Learning Courses with Free Certification

• 300+ Free Digital Marketing Certificates

• 900+ Open University Free Certificates

• 600+ Courses from Top Med Schools with Free Certificate & CME Credit

You can find all our free certificates articles here.

We talk about:

• Building AI systems from scratch

• How Elliot has learned so much so quickly and his methods

• How he approaches reading academic papers

• His CS degree coursework VS his self-directed learning

In the intro I play the 1988 Double Dragon II game soundtrack song "Into the Turf".

You can watch the interview on YouTube:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Join the 11,043 kind folks who support freeCodeCamp through a monthly donation. Join these kind folks and help our mission by going to https://www.freecodecamp.org/donate

Links we talk about during our conversation:

• Elliot's Mojo course on freeCodeCamp: https://www.freecodecamp.org/news/new-mojo-programming-language-for-ai-developers/

• Elliot's CUDA GPU programming course on freeCodeCamp: https://www.freecodecamp.org/news/learn-cuda-programming/

• Elliot's Python course on building an LLM from scratch: https://www.freecodecamp.org/news/how-to-build-a-large-language-model-from-scratch-using-python/

• Elliot's YouTube channel: https://www.youtube.com/@elliotarledge

• Elliot's many projects on GitHub: https://github.com/Infatoshi

🏗️ The new Certified Full Stack Developer curriculum is here!

🗨️ The new English for Developers CEFR Level B1

🤳 Major updates to our mobile apps

The freeCodeCamp Certified Full Stack Developer Path

Here's the full contents of the new Certified Full Stack Developer path. It's a doozy:

🛠️ 64 Workshops – Interactive step-by-step coding courses on tools ranging from HTML to SQL to Python (42 are now live)

🏛️ 513 Lectures – Short videos covering computer science concepts, with multiple choice questions to check your comprehension (313 are now live)

⚗️ 83 Labs – Projects where you start with a blank editor and a test suite, and have to build your project so that all the tests pass (60 are now live)

📰 62 Review Pages – Comprehensive lists of topics from each module that you can review to help you prepare for quizzes and exams (46 are now live)

🔬 66 Quizzes – To affirm your grasp of full stack development concepts and tools (46 are now live)

🏔️ 1 Capstone Project – a large, unique project that you'll build for your portfolio, reviewed by teachers within the freeCodeCamp community (Coming in 2025)

🤺 1 Final Exam – a comprehensive proctored 90-question certification exam taken within freeCodeCamp's new open source exam environment (Coming in 2025)

I recommend starting at the beginning, even if you’ve already learned some of these topics before.

You can dive right in and start working your way through the new Certified Full Stack Developer curriculum now.

The English for Developers Curriculum CEFR Level B1

Last Christmas, we released CEFR Level A2 English coursework.

And I’m thrilled to say that after a year of hard work, we’ve not only gotten all of that live – we’ve also now shipped a big chunk of Level B1.

The certification exams will come out in 2025 as well.

You can try our new CEFR Level B1 English for Developers certification curriculum.

The freeCodeCamp iPhone and Android Apps

The freeCodeCamp Mobile Apps are better than ever. Our Flutter codebase just hit 1,000 commits!

You can now:

📺 watch our courses

📚 read our books

🤳 Blaze through the curriculum right on your phone

Download it on iPhone/Android and leave a 5-star review. ⭐️⭐️⭐️⭐️⭐️ 😉

Get the Android app

Get the iPhone app

2025 is going to be amazing.

Thanks again to all of you who contribute to freeCodeCamp's curriculum and our many open source projects.

It's so cool that anyone can get help at any time from campers on the forum and Discord.

Encourage your friends to get involved. They can start with our open source contribution documentation.

Finally, thanks to all of you who donate to support freeCodeCamp's mission. We're just getting started.🥞

Please encourage your friends to support our charity as well. Together we can ensure everyone everywhere has access to a free world-class education. You can join 11,043 kind people around the world and become a supporter.

We talk about:
- Scott's perspective on the state of web dev
- His journey from video editing into full blown software development for agencies
- What he's learned from recording 2,000 tutorials and 800 web dev podcasts
- Productivity tips and how he's kept up this pace for 12 years without burning out

You can watch the interview on YouTube:

Or you can listen to the podcast in Apple Podcasts, Spotify, or your favorite podcast app. Be sure to follow the freeCodeCamp Podcast there so you'll get new episodes each Friday.

Links we talk about during our conversation:

Can you guess what song I'm playing in the intro?

Also, I want to thank the 11,036 kind people who support our charity each month, and who make this podcast possible. You can join them and support our mission at: https://www.freecodecamp.org/donate

Links we talk about during our conversation:

- The Syntax podcast: https://syntax.fm/

- Scott's archive of more than 1,000 programming tutorials he taught on YouTube: https://www.youtube.com/@syntaxfm/videos

- The Honeypot documentary about Scott (8 minute watch): https://www.youtube.com/watch?v=Q9eh2iJsjxE