DEV Community: codeFacility

What Is Recursion in Programming? A Beginner's Guide

codeFacility — Sun, 19 Jul 2026 19:01:26 +0000

Recursion is one of those topics that sounds intimidating until it clicks, and then it never stops being useful. At its core, it's a simple idea: a function that calls itself to break a big problem down into smaller versions of the same problem.

The Basic Idea

A recursive function does two things. First, it checks whether it has hit a simple case it can solve directly, called the base case. If not, it calls itself again with a smaller or simpler version of the input, called the recursive case. Each call gets closer to the base case until it's finally reached, and then all the calls resolve back up the chain.

Think of it like Russian nesting dolls. You keep opening smaller dolls until you hit the tiny solid one at the center. That solid doll is your base case. Without it, you'd be opening dolls forever.

A Classic Example: Factorial

The factorial of a number n (written n!) is the product of every whole number from 1 to n. Mathematically, n! = n × (n-1)!, which is already a recursive definition.

int factorial(int n) {
    if (n <= 1) {
        return 1; // base case
    }
    return n * factorial(n - 1); // recursive case
}

Calling factorial(4) triggers factorial(3), which triggers factorial(2), which triggers factorial(1). That last call hits the base case and returns 1, and then each call multiplies its way back up: 1, then 2, then 6, then 24.

Why the Base Case Matters So Much

If you forget a base case, or write one that's never actually reached, your function keeps calling itself indefinitely. Since each call takes up space on the call stack, this eventually crashes your program with a stack overflow. This is the single most common recursion bug, and it's worth double-checking every recursive function you write for a solid, reachable base case.

Recursion vs. Iteration

Almost anything you can write recursively, you can also write with a loop, and beginners often ask why bother with recursion at all. A few honest reasons:

Some problems are naturally recursive. Tree structures, nested folders, and anything with a "smaller version of itself" inside it tend to map cleanly onto recursive thinking. Traversing a file system or a binary tree is much cleaner recursively than with manual loops and stacks.

It can make code easier to read. A well-written recursive function often expresses the problem's logic more directly than an equivalent loop full of index tracking.

It's not always the efficient choice. Recursive calls have overhead, and deep recursion can be slower and more memory-hungry than an equivalent loop. For simple counting or summing tasks, iteration is usually the better tool.

A Second Example: Fibonacci

The Fibonacci sequence is another common recursion example, where each number is the sum of the two before it:

int fibonacci(int n) {
    if (n <= 1) {
        return n; // base case
    }
    return fibonacci(n - 1) + fibonacci(n - 2); // recursive case
}

This version is a great teaching example, but it's also a good lesson in recursion's downsides: it recalculates the same values over and over, making it very slow for larger n. That's a common follow-up topic once you're comfortable with recursion, called memoization.

Where to Go From Here

Recursion becomes intuitive with practice. Try rewriting simple loops as recursive functions, trace through the call stack by hand for something like factorial(5), and pay close attention to your base cases.

If you want to practice recursion hands-on with guided lessons and a live code playground, CodeFacility's Python courses cover recursion, functions, and problem-solving step by step and completely free.

What Is an API? A Beginner's Guide

codeFacility — Sun, 19 Jul 2026 18:58:42 +0000

What Is an API? A Beginner's Guide

You've probably heard the term API thrown around constantly in tech conversations, often as if everyone already knows what it means. The concept is actually pretty simple: an API is just a defined way for two pieces of software to talk to each other.

The Restaurant Menu Analogy

Think of an API like a menu at a restaurant. You don't walk into the kitchen and cook your own food, and you don't need to know how the kitchen works internally. You look at the menu, order something by name, and the kitchen hands you back a finished dish. The menu is the interface, a fixed set of things you're allowed to ask for, and how you ask for them.

An API works the same way for software. It's a defined set of requests one program can make to another, without needing to know anything about how that other program works internally.

Where APIs Show Up

Web APIs. When a weather app shows you today's forecast, it isn't calculating meteorology itself. It's sending a request to a weather service's API and displaying whatever data comes back.

Library and framework APIs. When you call a function like fetch() in JavaScript or len() in Python, you're using an API too, just one that's part of the language or a library rather than a separate service over the internet.

Operating system APIs. Apps request things like file access or notifications from your operating system through defined APIs, without needing to know how the OS manages hardware underneath.

What a REST API Request Actually Looks Like

Most APIs you'll interact with as a web developer are REST APIs, which organize everything around resources (like a specific user, or a specific post) and use standard HTTP methods to act on them:

GET /users/42 → retrieve user with ID 42
POST /users → create a new user
PUT /users/42 → update user 42's full data
DELETE /users/42 → delete user 42

Here's what a simple request to fetch data from an API looks like in JavaScript:

fetch("https://api.example.com/users/42")
  .then(response => response.json())
  .then(data => console.log(data));

This sends a GET request to the endpoint /users/42, and the API responds with data, usually formatted as JSON, that your code can then use.

Endpoints, Requests, and Responses

Endpoint. A specific URL an API exposes for a specific purpose, like /users or /products/5.

Request. What your code sends to the API, including the HTTP method, the endpoint, and sometimes a body containing data.

Response. What the API sends back, typically including a status code (like 200 for success or 404 for not found) and a body containing the requested data.

Why APIs Matter So Much

APIs are what let modern software be built out of pieces instead of from scratch every time. A payment app doesn't need to build its own banking infrastructure, it calls a payment API. A website doesn't need to build its own maps, it calls a mapping API. This is the foundation that makes the modern web modular and interconnected.

Where to Go From Here

APIs make the most sense once you actually call one. Try fetching data from a free public API and displaying it on a simple webpage, paying attention to the request you send and the JSON response you get back.

If you want to practice working with APIs hands-on with guided lessons and a live code playground, CodeFacility's JavaScript courses cover fetch requests, JSON, and working with real APIs step by step and completely free.

What Is a Pointer in C? A Beginner's Guide

codeFacility — Sun, 19 Jul 2026 18:43:22 +0000

What Is a Pointer in C? A Beginner's Guide

If you're learning C and pointers are the moment things suddenly feel harder, you're not alone. Pointers trip up more beginners than almost any other concept in the language. But the core idea is simpler than it looks once you strip away the confusing syntax: a pointer is just a variable that stores an address instead of a value.

A Variable Normally Stores a Value

When you write int age = 25;, C sets aside a small chunk of memory, gives it a label called age, and stores the number 25 inside it. Every variable in your program lives somewhere in memory, and every location in memory has an address, similar to a house having a street address.

Most of the time you don't think about that address at all. You just use the variable name and C handles the memory bookkeeping behind the scenes.

What a Pointer Actually Stores

A pointer is a variable, but instead of holding a regular value like a number or character, it holds the memory address of another variable. Here's what that looks like:

int age = 25;
int *agePointer = &age;

The & symbol means "give me the address of," and * when declaring a variable means "this variable is a pointer." So agePointer doesn't contain 25. It contains the address where 25 is stored.

If you want to see the value at that address, you dereference the pointer using * again: printf("%d", *agePointer); would print 25, not the address.

Why Not Just Use the Variable Directly?

This is the question that trips up most beginners, and it's a fair one. If you already have age, why bother with a pointer to it?

The real value of pointers shows up in a few common situations:

Passing large data to functions. When you pass a variable to a function in C, it normally gets copied. For a single integer that's cheap, but for a large array or struct, copying is wasteful. Passing a pointer instead means the function works with the original data directly, without duplicating it.

Modifying a variable inside a function. Normally, changes made to a parameter inside a function don't affect the original variable outside it. Pointers let a function reach outside itself and modify the original data, which is essential for things like swap functions or updating values through function calls.

Dynamic memory allocation. Functions like malloc() return a pointer to newly allocated memory. Without pointers, there'd be no way to work with memory that's created while your program is running rather than fixed at compile time.

Working with arrays and strings. In C, array names actually behave like pointers to their first element. Understanding pointers makes array and string handling in C make a lot more sense.

A Simple Example

Here's a small program that shows a pointer changing a value through a function, something that wouldn't be possible without one:

void doubleValue(int *num) {
    *num = *num * 2;
}

int main() {
    int x = 10;
    doubleValue(&x);
    printf("%d", x); // prints 20
    return 0;
}

Without the pointer, doubleValue would only be doubling a copy of x, and the original x in main() would stay at 10. Because we passed the address instead, the function reaches into the original variable and changes it directly.

Common Pointer Mistakes to Watch For

A few habits will save you a lot of debugging time as you get comfortable with pointers:

Uninitialized pointers. A pointer that hasn't been assigned an address points to a random, unpredictable location. Dereferencing it can crash your program or corrupt memory. Always initialize a pointer, even if it's just to NULL.

Dereferencing NULL. Trying to read or write through a pointer that's set to NULL will crash your program. It's good practice to check a pointer isn't NULL before using it.

Forgetting to free allocated memory. If you allocate memory with malloc(), you're responsible for releasing it with free() when you're done. Forgetting to do this causes memory leaks.

Where to Go From Here

Pointers become much clearer with practice than with explanation alone. The best way to build real intuition is to write small programs that pass values by pointer, experiment with arrays and pointers together, and get comfortable with dynamic memory allocation using malloc and free.

If you want to practice pointers hands-on with guided lessons and a live code playground, CodeFacility's Advanced C course covers pointers, memory management, and more, step by step and completely free.

I made a new non-profit coding website that is completely for free. No BS!!

codeFacility — Thu, 02 Jul 2026 23:34:58 +0000

Hi everyone!

Over the past few months, I've been working on a coding website that's completely free and has no annoying ads or paywalls. It's completely non-profit and I just wanted to make learning coding much more accessible. My goal was to create something that helps beginners actually understand programming instead of just copying AI-generated code.

I'd genuinely love some feedback on the design, lessons, and overall experience. If you have a few minutes to check it out, I'd really appreciate it. Please let me know if there are any problems!

Website: codefacility.com

Thanks!