Parker Jones Dev Blog - mastering-c

Mastering C with Effective C: Introduction to Makefiles

2024-06-14T00:00:00+00:00

Mastering C with Effective C: Introduction to Makefiles</h3>

Introduction</h4>
Welcome to the first post in the "Mastering C with Effective C" series</a>! In this post, we'll explore the basics of Makefiles and how they can help you manage and automate the build process of your C projects. Makefiles are an essential tool for any C programmer, simplifying the compilation process, managing dependencies, and ensuring efficient builds.</p>

What is a Makefile?</h4>
A Makefile is a special file, containing a set of directives used by the `make</code> build automation tool to compile and link a program. It defines rules on how to build different parts of your project, making it easier to manage larger projects with multiple source files.</p>`
`Benefits of Using Makefiles</h4>`

Automation</strong>: Automates the compilation process, reducing the chances of human error.</li>
Efficiency</strong>: Only rebuilds the parts of the project that have changed, saving time during development.</li>
Organization</strong>: Keeps build instructions in a single, easy-to-read file.</li>
Portability</strong>: Ensures that your project can be built consistently across different environments.</li> </ul>
Basic Structure of a Makefile</h4>
A Makefile typically consists of rules. Each rule defines how to build a target from its dependencies. The general structure is:</p>
`target: dependencies command </code></pre>`target</strong>: The file to be generated (e.g., executable or object file).</li> dependencies</strong>: The files that the target depends on (e.g., source files).</li> command</strong>: The command to generate the target from the dependencies (e.g., compile command).</li> </ul> Example: A Simple Makefile</h4> Let's start with a simple example. Suppose we have a project with three source files: main.c</code>, file1.c</code>, and file2.c</code>. Here's a basic Makefile to compile these files into a single executable:</p> # the compiler to use CC = clang # compiler flags: # -g adds debugging information to the executable file # -Wall turns on most, but not all, compiler warnings CFLAGS = -g -Wall # files to link: LFLAGS = #-lcs50 # the name to use for the output file: TARGET = my_program # the list of source files SRCS = main.c file1.c file2.c # the list of object files (derived from the source files) OBJS = $(SRCS:.c=.o) all: $(TARGET) $(TARGET): $(OBJS) $(CC) $(CFLAGS) -o $(TARGET) $(OBJS) $(LFLAGS) %.o: %.c $(CC) $(CFLAGS) -c $< -o $@ clean: rm -f $(OBJS) $(TARGET) </code></pre> Breaking Down the Makefile</h4> Compiler and Flags</strong>: We specify the compiler (clang</code>) and the compiler flags (CFLAGS</code>).</li> Source and Object Files</strong>: SRCS</code> lists the source files, and OBJS</code> lists the corresponding object files.</li> Build Rules</strong>: all: $(TARGET)</code>: The default target, which builds the executable.</li> $(TARGET): $(OBJS)</code>: The rule to link the object files into the final executable.</li> %.o: %.c</code>: A pattern rule to compile source files into object files.</li> </ul> </li> Clean Rule</strong>: The clean</code> rule removes the generated object files and the executable.</li> </ul> Using the Makefile</h4> To use the Makefile, simply run the make</code> command in the terminal within the project directory. This will compile and link the source files into the my_program</code> executable.</p> make </code></pre> To clean up the generated files, run:</p> make clean </code></pre> Additional Resources</h4> For more information and deeper dives into Makefiles, check out these resources:</p> GNU Make Manual</a></li> GNU Make on Wikipedia</a></li> Makefile Tutorial - TutorialsPoint</a></li> Makefile Tutorial by Example</a></li> CMake Documentation</a></li> </ul> Conclusion</h4> Makefiles are a powerful tool for managing the build process of your C projects. By automating compilation and linking, they save time and reduce errors. In this post, we covered the basics of Makefiles, their benefits, and how to create a simple Makefile for a C project.</p> Next Up</h4> Stay tuned for the next post in the "Mastering C with Effective C" series, where we'll dive into data types and variables in C. We will explore different data types, how to declare and use variables, and the importance of understanding data representation.</p> Happy coding!</p>



Mastering C: Building a Project with Nix Flakes
2024-06-14T00:00:00+00:00
Upgrading Your C Project Build to Use Nix Flakes: A Modern Guide</h1>
Hello again, fellow C enthusiasts! In our previous blog post, we explored building a C program with external library dependencies using Nix. Today, we’re taking it a step further by upgrading our Nix setup to use Nix flakes, a more structured and modern way to manage dependencies and ensure reproducibility. This post will guide you through updating your existing Nix build to a Nix flake and explain each component in detail. Let’s dive in!</p>
What Are Nix Flakes?</h2>
Nix flakes introduce a standardized way to define Nix projects, providing better dependency management, versioning, and reproducibility. They offer:</p>

Consistency</strong>: Ensures builds are reproducible across different environments.</li>
Ease of Use</strong>: Simplifies the setup and management of dependencies.</li>
Modularity</strong>: Allows sharing and composing Nix expressions easily.</li>
</ul>
For more details, you can check out the Nix Flakes documentation</a>.</p>
Transitioning from a Classic Nix Setup to Nix Flakes</h2>
We’ll start with our simple-parse-example</code> C program, which uses the jansson</code> library for JSON parsing. We’ll convert our existing default.nix</code> to a flake.nix</code> file.</p>
Original default.nix</code></h3>
Here’s a quick look at our original default.nix</code>:</p>
{ pkgs ? import <nixpkgs> {} }:

let
  jansson = pkgs.jansson;
in
pkgs.stdenv.mkDerivation {
  pname = "simple-parse-example";
  version = "1.0";

  src = ./.;

  nativeBuildInputs = [ pkgs.clang ];
  buildInputs = [ jansson ];

  buildPhase = ''
    clang -g -Wall -o simple-parse-example simple-parse-example.c -ljansson
  '';

  installPhase = ''
    mkdir -p $out/bin
    cp simple-parse-example $out/bin/
  '';

  meta = with pkgs.lib; {
    description = "A simple program using jansson";
    license = licenses.mit;
    maintainers = [ maintainers.yourname ];
    platforms = platforms.unix;
  };
}
</code></pre>
Converting to flake.nix</code></h3>
We’ll now convert this setup to use Nix flakes.</p>
Step 1: Creating flake.nix</code></h4>
Create a file named flake.nix</code> in your project directory with the following content:</p>
{
  description = "A simple C program using jansson built with Nix flakes";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
  };

  outputs = { self, nixpkgs }: {
    packages = nixpkgs.lib.genAttrs [ "aarch64-darwin" "x86_64-linux" ] (system:
    let
      pkgs = import nixpkgs { inherit system; };
    in
    rec {
      simple-parse-example = pkgs.stdenv.mkDerivation {
        pname = "simple-parse-example";
        version = "1.0";

        src = ./.;

        nativeBuildInputs = [ pkgs.clang ];
        buildInputs = [ pkgs.jansson ];

        buildPhase = ''
          clang -g -Wall -o simple-parse-example simple-parse-example.c -ljansson
        '';

        installPhase = ''
          mkdir -p $out/bin
          cp simple-parse-example $out/bin/
        '';

        meta = with pkgs.lib; {
          description = "A simple program using jansson";
          license = licenses.mit;
          maintainers = [ maintainers.yourname ];
          platforms = platforms.unix;
        };
      };
    });

    defaultPackage = {
      aarch64-darwin = self.packages.aarch64-darwin.simple-parse-example;
      x86_64-linux = self.packages.x86_64-linux.simple-parse-example;
    };

    defaultApp = {
      forAllSystems = nixpkgs.lib.mapAttrs' (system: pkg: {
        inherit system;
        defaultApp = {
          type = "app";
          program = "${pkg.simple-parse-example}/bin/simple-parse-example";
        };
      }) self.packages;
    };
  };
}
</code></pre>
Breaking Down the Flake Configuration</h3>
Let’s break down each component of the flake.nix</code> file to understand what it does.</p>
1. description</strong></h4>
description = "A simple C program using jansson built with Nix flakes";
</code></pre>
This provides a brief description of the flake. It’s useful for documentation and understanding the purpose of the flake.</p>
2. inputs</strong></h4>
inputs = {
  nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
};
</code></pre>
The inputs</code> section defines dependencies for the flake. Here, we are specifying that we want to use the unstable branch of the Nixpkgs repository. This is where we’ll get our packages like clang</code> and jansson</code>.</p>

Documentation</strong>: Nixpkgs Input</a></li>
</ul>
3. outputs</strong></h4>
outputs = { self, nixpkgs }: {
  packages = nixpkgs.lib.genAttrs [ "aarch64-darwin" "x86_64-linux" ] (system:
  let
    pkgs = import nixpkgs { inherit system; };
  in
  rec {
    simple-parse-example = pkgs.stdenv.mkDerivation {
      pname = "simple-parse-example";
      version = "1.0";

      src = ./.;

      nativeBuildInputs = [ pkgs.clang ];
      buildInputs = [ pkgs.jansson ];

      buildPhase = ''
        clang -g -Wall -o simple-parse-example simple-parse-example.c -ljansson
      '';

      installPhase = ''
        mkdir -p $out/bin
        cp simple-parse-example $out/bin/
      '';

      meta = with pkgs.lib; {
        description = "A simple program using jansson";
        license = licenses.mit;
        maintainers = [ maintainers.yourname ];
        platforms = platforms.unix;
      };
    };
  });

  defaultPackage = {
    aarch64-darwin = self.packages.aarch64-darwin.simple-parse-example;
    x86_64-linux = self.packages.x86_64-linux.simple-parse-example;
  };

  defaultApp = {
    forAllSystems = nixpkgs.lib.mapAttrs' (system: pkg: {
      inherit system;
      defaultApp = {
        type = "app";
        program = "${pkg.simple-parse-example}/bin/simple-parse-example";
      };
    }) self.packages;
  };
};
</code></pre>


packages</strong>: This section uses nixpkgs.lib.genAttrs</code> to define packages for multiple systems (aarch64-darwin</code> and x86_64-linux</code>). For each system, we import the appropriate version of nixpkgs</code> and define a derivation for simple-parse-example</code>.</p>
</li>

defaultPackage</strong>: Specifies the default package for each system. This is used to tell Nix which package to build by default for the current system.</p>
</li>

defaultApp</strong>: Specifies the default application for each system using mapAttrs'</code> to iterate over systems and create default apps.</p>
</li>

Documentation</strong>:</p>

genAttrs</a></li>
mkDerivation</a></li>
</ul>
</li>
</ul>
Building and Running with Nix Flakes</h3>
To ensure that everything works as expected, follow these steps:</p>


Navigate to your project directory</strong>:</p>
cd ~/dev/learning-c/parsing-json
</code></pre>
</li>

Enable Flakes</strong>:
Make sure flakes are enabled in your Nix configuration:</p>
echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf
</code></pre>
</li>

Build the project</strong>:
Build the project using:</p>
nix build .#simple-parse-example
</code></pre>
</li>

Run the binary</strong>:
After building, you can run the binary with:</p>
./result/bin/simple-parse-example
</code></pre>
</li>
</ol>
Conclusion</h3>
Congratulations! You've successfully updated your C project to use Nix flakes. This modern approach ensures your builds are reproducible and dependencies are well-managed. Nix flakes provide a powerful way to handle complex projects with ease, making your development process smoother and more efficient.</p>
Exercise Prompt</h3>
Try converting another one of your existing projects to use Nix flakes. Start by writing a flake.nix</code> file that includes all your dependencies and build instructions. Share your experience, any challenges you encountered, and how Nix flakes improved your build process.</p>
Happy coding, and may your builds always be reproducible!</p>


Mastering C: Building a Project with Nix
2024-06-14T00:00:00+00:00
Welcome, fellow C enthusiasts, to a whimsical journey through the world of library dependencies in C programming! This is the second post in the series "Mastering C with Effective C" series</a>!  Not at all suprising to me, I've yet to write anything at all from the book, and I'm still poking around with build systems.  I've been learning to use nix as a build system, and some things are becoming clear when learning C, which has no built in package manager...</p>
Today, we will dive into the exciting realm of building C programs with external libraries, and we’ll showcase how to do it using Nix, a modern build system that promises reproducibility and simplicity. But don't worry, we’ll also touch upon the classic Makefile approach for comparison. Let’s get started!</p>
The code from this post can be found here</a></p>
The Challenge of Library Dependencies in C</h2>
Before we embark on our adventure, let's acknowledge the challenge: managing external libraries in C. While modern languages often come with robust package managers, C developers often find themselves navigating the rugged terrain of manual downloads and builds. But fear not! With the power of Nix, we can transform this daunting task into a delightful experience.</p>
Introducing Our Hero: The Simple JSON Parsing Example</h2>
To illustrate our journey, we'll create a C program called simple-parse-example</code>. This program will demonstrate basic JSON parsing using the jansson</code> library. Here’s what it will do:</p>

Create a JSON object.</li>
Serialize the JSON object to a string.</li>
Parse a JSON string back into an object.</li>
Print the values to prove we’ve successfully navigated the JSON landscape.</li>
</ul>
The C Program: simple-parse-example</code></h3>
Here’s our simple C program using the jansson</code> library:</p>
// simple-parse-example.c
#include <stdio.h>
#include <jansson.h>

int main() {
    // Creating a JSON object
    json_t *object = json_object();
    json_object_set_new(object, "name", json_string("Candlehopper"));
    json_object_set_new(object, "level", json_integer(5));
    json_object_set_new(object, "score", json_integer(12345));

    // Serialize JSON object to string
    char *json_str = json_dumps(object, JSON_INDENT(2));
    if (!json_str) {
        fprintf(stderr, "Error serializing JSON object.\n");
        return 1;
    }
    printf("Serialized JSON:\n%s\n", json_str);

    // Free the serialized string
    free(json_str);

    // JSON string to parse
    const char *json_input = "{\"name\": \"Candlehopper\", \"level\": 5, \"score\": 12345}";

    // Parse JSON string
    json_error_t error;
    json_t *parsed_object = json_loads(json_input, 0, &error);
    if (!parsed_object) {
        fprintf(stderr, "Error parsing JSON string: %s\n", error.text);
        return 1;
    }

    // Extract values
    json_t *name = json_object_get(parsed_object, "name");
    json_t *level = json_object_get(parsed_object, "level");
    json_t *score = json_object_get(parsed_object, "score");

    if (json_is_string(name) && json_is_integer(level) && json_is_integer(score)) {
        printf("Parsed JSON:\n");
        printf("name: %s\n", json_string_value(name));
        printf("level: %lld\n", json_integer_value(level));
        printf("score: %lld\n", json_integer_value(score));
    } else {
        fprintf(stderr, "Error extracting values from JSON object.\n");
        json_decref(parsed_object);
        return 1;
    }

    // Decrement reference counts to free memory
    json_decref(object);
    json_decref(parsed_object);

    return 0;
}
</code></pre>
The Classic Approach: Using Makefile</h2>
First, let’s explore how to build this program using a Makefile. Here’s a simple Makefile to compile simple-parse-example</code> with the jansson</code> library:</p>
Makefile</h3>
# the compiler to use
CC = clang

# compiler flags:
#  -g    adds debugging information to the executable file
#  -Wall turns on most, but not all, compiler warnings
CFLAGS  = -g -Wall
  
# files to link:
LFLAGS = -ljansson
  
# the names to use for both the target source files, and the output files:
TARGETS = simple-parse-example
  
all: $(TARGETS)
  
simple-parse-example: simple-parse-example.c
	$(CC) $(CFLAGS) -o simple-parse-example simple-parse-example.c $(LFLAGS)

clean:
	rm -f $(TARGETS)
</code></pre>
To build the project:</p>
make
</code></pre>
To clean up the build files:</p>
make clean
</code></pre>
Pros and Cons of the Makefile Approach</h3>
Pros:</strong></p>

Simple and straightforward.</li>
Easily integrates with various compilers and tools.</li>
</ul>
Cons:</strong></p>

Manual management of dependencies.</li>
Non-reproducible builds.</li>
Platform-specific issues.</li>
</ul>
The Modern Approach: Using Nix</h2>
Now, let's switch gears and harness the power of Nix to build our project. Nix provides reproducibility and isolation, ensuring our builds are consistent across different environments.</p>
Nix Setup</h3>
Here’s how you can set up a default.nix</code> file to build simple-parse-example</code>:</p>
# default.nix
{ pkgs ? import <nixpkgs> {} }:

let
  jansson = pkgs.jansson;
in
pkgs.stdenv.mkDerivation {
  pname = "simple-parse-example";
  version = "1.0";

  src = ./.;

  nativeBuildInputs = [ pkgs.clang ];
  buildInputs = [ jansson ];

  buildPhase = ''
    clang -g -Wall -o simple-parse-example simple-parse-example.c -ljansson
  '';

  installPhase = ''
    mkdir -p $out/bin
    cp simple-parse-example $out/bin/
  '';

  meta = with pkgs.lib; {
    description = "A simple program using jansson";
    license = licenses.mit;
    maintainers = [ maintainers.yourname ];
    platforms = platforms.unix;
  };
}
</code></pre>
Building with Nix</h3>
To build your project using Nix:</p>


Navigate to your project directory</strong>:</p>
cd myproject
</code></pre>
</li>

Build the project</strong>:</p>
nix-build
</code></pre>
</li>

Run the binary</strong>:</p>
./result/bin/simple-parse-example
</code></pre>
</li>
</ol>
Pros and Cons of the Nix Approach</h3>
Pros:</strong></p>

Reproducible builds.</li>
Easy dependency management.</li>
Environment isolation.</li>
</ul>
Cons:</strong></p>

Steeper learning curve.</li>
Requires Nix installation.</li>
</ul>
Exploring Other Build Tools</h2>
While Makefiles and Nix are fantastic tools, there are other build systems and package managers worth exploring:</p>

CMake</strong>: A cross-platform build system that automates the configuration process. Learn more</a>.</li>
vcpkg</strong>: A C/C++ library manager from Microsoft. Learn more</a>.</li>
Conan</strong>: A decentralized package manager for C/C++. Learn more</a>.</li>
</ol>
Conclusion</h2>
In this quirky adventure, we’ve explored the classic Makefile approach and the modern Nix approach to building a C program with external library dependencies. We’ve seen how Nix can bring reproducibility and ease of use to the table, making it a fantastic choice for C developers looking to streamline their build processes.</p>



Happy coding, and may your builds always be reproducible!</p>


Blog Post Series: Mastering C with Effective C
2024-06-14T00:00:00+00:00
Introduction</h2>
Welcome to my blog series, "Mastering C with Effective C"! This series is dedicated to exploring the fundamental concepts and advanced techniques of the C programming language. Inspired by the book Effective C</a> by Robert C. Seacord</a>, each post will delve into different aspects of C as I work through this book and make an effort to write a blog post every day.</p>
My ultimate goal is to become comfortable with the C programming language, but ultimately use Zig</a>.... but first we're going to touch the stove. You have to get burned to understand why you need the safety and quality of life improvements.</p>
For the past few years I've gone pretty hard learning and working every day in Rust. I began my Rust journey as a (primarily) Typescript and Javascript develper. I began my software engineer as a web developer writing PHP, JavaScript, Typescript, HTML,and CSS.</p>
As a self taught developer, I've built my career on learning side quests, which I've always considered par for the course as a software engineer.</p>
I'll be working through examples and sharing the code from the series in the following Git Repo</a></p>
What to Expect</h2>
In this series, we'll cover a wide range of topics, starting from the basics and gradually moving towards more advanced concepts. Here are some of the key areas we'll explore:</p>

Getting Started with C</strong>: Understanding the basic structure of a C program, setting up the development environment, and writing your first C program.</li>
Data Types and Variables</strong>: Exploring different data types in C, how to declare and use variables, and the importance of understanding data representation.</li>
Control Structures</strong>: Learning about various control structures such as loops, conditional statements, and how to control the flow of your program.</li>
Functions and Modular Programming</strong>: Understanding the role of functions in C, how to define and call them, and the benefits of modular programming.</li>
Pointers and Memory Management</strong>: Delving into pointers, dynamic memory allocation, and techniques for effective memory management in C.</li>
Advanced Topics</strong>: Covering topics such as file I/O, multi-threading, and network programming.</li>
</ol>
Each post will include practical examples, exercises, and explanations to help solidify your understanding of the concepts.</p>
Link to Subsequent Posts</h4>
This section will be updated with links to each post in the series as they are published. Stay tuned for new content and be sure to check back regularly!</p>

Introduction to Makefiles</strong>: Read Post</a></li>
Converting Makefile to a nix build</strong>: Read Post</a></li>
Neovim Configuration for Writing C: [Coming Soon]</li>
Data Types and Variables: [Coming Soon]</li>
Control Structures: [Coming Soon]</li>
Functions and Modular Programming: [Coming Soon]</li>
Pointers and Memory Management: [Coming Soon]</li>
Advanced Topics: [Coming Soon]</li>
</ol>
Next Up: Introduction to Makefiles</h4>
In the next post, we'll dive into the world of Makefiles. We'll explore how to automate the build process, manage dependencies, and simplify your workflow using Makefiles. This will include practical examples and a step-by-step guide to creating your own Makefile for a C project.</p>
Stay tuned and happy coding!</p>

Conclusion</h4>
Makefiles are a powerful tool for managing the build process of your C projects. By automating compilation and linking, they save time and reduce errors. In this post, we covered the basics of Makefiles, their benefits, and how to create a simple Makefile for a C project.</p>

Next Up</h4>
Stay tuned for the next post in the "Mastering C with Effective C" series, where we'll dive into data types and variables in C. We will explore different data types, how to declare and use variables, and the importance of understanding data representation.</p>

Happy coding!</p>

Breaking Down the Flake Configuration</h3>
Let’s break down each component of the `flake.nix</code> file to understand what it does.</p>`

The Classic Approach: Using Makefile</h2>
First, let’s explore how to build this program using a Makefile. Here’s a simple Makefile to compile `simple-parse-example</code> with the jansson</code> library:</p>`

The Modern Approach: Using Nix</h2>
Now, let's switch gears and harness the power of Nix to build our project. Nix provides reproducibility and isolation, ensuring our builds are consistent across different environments.</p>

Parker Jones Dev Blog - mastering-c

Mastering C with Effective C: Introduction to Makefiles

Mastering C with Effective C: Introduction to Makefiles</h3>

Mastering C: Building a Project with Nix Flakes

Mastering C: Building a Project with Nix

Blog Post Series: Mastering C with Effective C

Parker Jones Dev Blog - mastering-c

Mastering C with Effective C: Introduction to Makefiles

Mastering C with Effective C: Introduction to Makefiles</h3>

Basic Structure of a Makefile</h4> A Makefile typically consists of rules. Each rule defines how to build a target from its dependencies. The general structure is:</p>

Conclusion</h4> Makefiles are a powerful tool for managing the build process of your C projects. By automating compilation and linking, they save time and reduce errors. In this post, we covered the basics of Makefiles, their benefits, and how to create a simple Makefile for a C project.</p>

Next Up</h4> Stay tuned for the next post in the "Mastering C with Effective C" series, where we'll dive into data types and variables in C. We will explore different data types, how to declare and use variables, and the importance of understanding data representation.</p> Happy coding!</p>

Mastering C: Building a Project with Nix Flakes

What Are Nix Flakes?</h2> Nix flakes introduce a standardized way to define Nix projects, providing better dependency management, versioning, and reproducibility. They offer:</p>

Breaking Down the Flake Configuration</h3> Let’s break down each component of the flake.nix</code> file to understand what it does.</p>

Mastering C: Building a Project with Nix

Introducing Our Hero: The Simple JSON Parsing Example</h2> To illustrate our journey, we'll create a C program called simple-parse-example</code>. This program will demonstrate basic JSON parsing using the jansson</code> library. Here’s what it will do:</p>

The Classic Approach: Using Makefile</h2> First, let’s explore how to build this program using a Makefile. Here’s a simple Makefile to compile simple-parse-example</code> with the jansson</code> library:</p>

The Modern Approach: Using Nix</h2> Now, let's switch gears and harness the power of Nix to build our project. Nix provides reproducibility and isolation, ensuring our builds are consistent across different environments.</p>

Blog Post Series: Mastering C with Effective C

Link to Subsequent Posts</h4> This section will be updated with links to each post in the series as they are published. Stay tuned for new content and be sure to check back regularly!</p>

Conclusion</h4>
Makefiles are a powerful tool for managing the build process of your C projects. By automating compilation and linking, they save time and reduce errors. In this post, we covered the basics of Makefiles, their benefits, and how to create a simple Makefile for a C project.</p>

Next Up</h4>
Stay tuned for the next post in the "Mastering C with Effective C" series, where we'll dive into data types and variables in C. We will explore different data types, how to declare and use variables, and the importance of understanding data representation.</p>

Happy coding!</p>

Breaking Down the Flake Configuration</h3>
Let’s break down each component of the `flake.nix</code> file to understand what it does.</p>`

The Classic Approach: Using Makefile</h2>
First, let’s explore how to build this program using a Makefile. Here’s a simple Makefile to compile `simple-parse-example</code> with the jansson</code> library:</p>`

The Modern Approach: Using Nix</h2>
Now, let's switch gears and harness the power of Nix to build our project. Nix provides reproducibility and isolation, ensuring our builds are consistent across different environments.</p>