<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Build From Zero</title>
    <link>https://buildfromzero.com/</link>
    <description>Recent content on Build From Zero</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Wed, 09 Sep 2026 10:00:00 +0200</lastBuildDate><atom:link href="https://buildfromzero.com/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>How I Built CVBlender: Building an AI-Powered CV Builder From Scratch</title>
      <link>https://buildfromzero.com/posts/how-i-built-cvblender-an-ai-powered-cv-builder/</link>
      <pubDate>Wed, 09 Sep 2026 10:00:00 +0200</pubDate>
      
      <guid>https://buildfromzero.com/posts/how-i-built-cvblender-an-ai-powered-cv-builder/</guid>
      <description>Why build another CV builder? Earlier this year I set out to build a CV builder as a side project. Not because the world is short of them, but because every time I had to update my own CV I ran into the same three problems.
First, most online CV builders are subscription traps. You spend an hour entering your work history, and only when you press download do you learn that the PDF costs a monthly subscription you will forget to cancel.</description>
    </item>
    
    <item>
      <title>Build Private Rust Crates in GitLab CI Pipelines</title>
      <link>https://buildfromzero.com/posts/gitlab-pipeline-build-with-private-rust-crates/</link>
      <pubDate>Fri, 16 Aug 2024 10:01:35 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/gitlab-pipeline-build-with-private-rust-crates/</guid>
      <description>If your Rust project depends on a crate that lives in a private GitLab repository, the first CI run fails with a wall of failed to authenticate when downloading repository errors. Cargo can clone the dependency on your laptop because your SSH key is loaded. The CI runner has no key, no credentials and no idea who you are.
This post shows the three small pieces that fix it: a before_script that hands Cargo a short-lived token, a Cargo.</description>
    </item>
    
    <item>
      <title>Iotcore: Python MQTT Broker for Django and FastAPI (Rust Core)</title>
      <link>https://buildfromzero.com/posts/iotcore-python-mqtt-server-django-fastapi/</link>
      <pubDate>Wed, 18 Jan 2023 15:01:35 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/iotcore-python-mqtt-server-django-fastapi/</guid>
      <description>Most Python IoT backends run an MQTT broker as a separate service, usually Mosquitto, and then talk to it over a client library. That is one more process to deploy, configure and keep alive. Iotcore takes a different approach: it embeds the broker inside your Django or FastAPI application as a Python package, so pip install iotcore and a few lines of code give you a running MQTT broker on port 1883 with no external dependency.</description>
    </item>
    
    <item>
      <title>Concurrency vs Parallelism Explained (With Go Examples)</title>
      <link>https://buildfromzero.com/posts/concurrency-vs-parallelism/</link>
      <pubDate>Tue, 17 Jan 2023 15:01:35 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/concurrency-vs-parallelism/</guid>
      <description>Concurrency and parallelism get used as synonyms, and most of the confusion about goroutines, threads and async code comes from that. They are different ideas, they solve different problems, and a program can have either one without the other. The video above walks through it on a whiteboard; this is the written version with Go examples you can run.
The one-sentence difference Concurrency is about structure: dealing with many things at once.</description>
    </item>
    
    <item>
      <title>Rust Explained: Ownership, Borrowing, Safety and Speed</title>
      <link>https://buildfromzero.com/posts/rust-introduction/</link>
      <pubDate>Mon, 16 Jan 2023 15:01:35 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/rust-introduction/</guid>
      <description>Rust is a compiled systems programming language with strong static typing and no garbage collector. Its distinguishing idea is that memory safety is checked by the compiler rather than at runtime, so a whole class of bugs that crash C and C++ programs, including use-after-free, double free and data races, cannot be written in safe Rust at all. This guide covers why that matters, what the language looks like and the ownership and borrowing rules that make it work, with short examples you can paste into a main.</description>
    </item>
    
    <item>
      <title>Python Dependency Management: pip vs Poetry Cheat Sheet</title>
      <link>https://buildfromzero.com/posts/python-dependency-management-pip-and-poetry/</link>
      <pubDate>Thu, 12 Jan 2023 15:01:35 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/python-dependency-management-pip-and-poetry/</guid>
      <description>Every Python project has to answer the same two questions: how do I install the packages I need, and how do I make sure the next machine gets exactly the same ones? pip answers the first well and the second badly. Poetry answers both, at the cost of learning a new tool. This cheat sheet puts the everyday commands side by side so you can switch between them without looking anything up.</description>
    </item>
    
    <item>
      <title>Command Design Pattern in Python: A Practical Example</title>
      <link>https://buildfromzero.com/posts/command-design-pattern-in-python/</link>
      <pubDate>Mon, 09 Jan 2023 15:01:35 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/command-design-pattern-in-python/</guid>
      <description>The command pattern turns an action into an object. Instead of calling add(1, 1) directly, you build an AddCmd(1, 1) object and ask it to execute() later. That indirection sounds like extra work until you need to queue actions, log them, undo them or pick one by name at runtime. Then it is the simplest design available.
This post builds a small calculator with the pattern in Python: an abstract command, two concrete commands, a registry that lets you look commands up by name and a test that proves it works.</description>
    </item>
    
    <item>
      <title>Generate a ZIP File From a List of Files in Django</title>
      <link>https://buildfromzero.com/posts/how-to-generate-a-zip-file-from-given-file-list/</link>
      <pubDate>Sat, 07 Jan 2023 15:01:35 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/how-to-generate-a-zip-file-from-given-file-list/</guid>
      <description>A common Django request: the user selects several uploaded files and wants them as one download. Serving them one by one is tedious, and building the archive on disk leaves temporary files behind on every request. The cleanest answer is to build the ZIP in memory and stream it back as an HTTP response.
This post walks through a reusable mixin that does exactly that. Drop it on any class-based view and call self.</description>
    </item>
    
    <item>
      <title>Zephyr RTOS - Taking Your Embedded Projects to the Next Level</title>
      <link>https://buildfromzero.com/posts/zephyr-rtos-taking-your-embedded-projects-to-the-next-level/</link>
      <pubDate>Fri, 06 Jan 2023 15:01:35 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/zephyr-rtos-taking-your-embedded-projects-to-the-next-level/</guid>
      <description>Zephyr is an open-source real-time operating system for microcontrollers and other resource-constrained devices, governed by the Linux Foundation. It gives you a scheduler, device drivers, networking and Bluetooth stacks, a build system and a hardware abstraction layer that runs the same application on hundreds of boards from different vendors. This post explains what Zephyr is, why it has become the default choice for new embedded projects and how to build and flash your first application.</description>
    </item>
    
    <item>
      <title>Gorf: A Django-Inspired REST Framework for Go</title>
      <link>https://buildfromzero.com/posts/gorf-django-inspired-web-framework-for-golang/</link>
      <pubDate>Sat, 08 Oct 2022 18:05:55 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/gorf-django-inspired-web-framework-for-golang/</guid>
      <description>Go gives you a fast HTTP server and a good router in Gin, and then leaves every structural decision to you: where models live, how routes are grouped, how a new feature is added without touching the rest. Coming from Django, I missed the answer Django gives to all of that, the app. Gorf is my attempt to bring that structure to Go.
A Gorf project is a set of apps.</description>
    </item>
    
    <item>
      <title>Go Programming Introduction: Build a User System With Gin</title>
      <link>https://buildfromzero.com/posts/go-programming-introduction-english/</link>
      <pubDate>Fri, 07 Oct 2022 15:01:35 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/go-programming-introduction-english/</guid>
      <description>This is the written companion to the video above: a first Go backend, built with the Gin web framework, that creates and lists users. If you have never written Go before, you can follow this top to bottom in about half an hour; if you have, skim to the handlers.
Why Go for a backend Go compiles to a single static binary, starts in milliseconds, and handles concurrent requests with goroutines rather than threads or an event loop you have to reason about.</description>
    </item>
    
    <item>
      <title>C Programming Refresher: Pointers, Casts and Byte Parsing</title>
      <link>https://buildfromzero.com/posts/refresh-c-programming/</link>
      <pubDate>Sun, 15 May 2022 15:01:35 +0300</pubDate>
      
      <guid>https://buildfromzero.com/posts/refresh-c-programming/</guid>
      <description>Most of my C is written for microcontrollers, often inside Zephyr RTOS applications, and months can pass between projects. These are the idioms I look up every time I come back: casting opaque buffers, parsing integers out of byte arrays and wiring callbacks. Each snippet is short, compiles on its own and is annotated with the detail that usually trips me up.
Casting a void pointer to a byte array Driver callbacks often hand you const void *data and a length.</description>
    </item>
    
    <item>
      <title>About</title>
      <link>https://buildfromzero.com/about/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://buildfromzero.com/about/</guid>
      <description>Build From Zero is a blog about building software and hardware from the ground up, written by me, Tom Victor — a programmer and entrepreneur who would rather understand how something works than trust that it does.
What you will find here Most of what I publish falls into one of four areas:
Rust and systems programming. Why Rust exists, how ownership and borrowing actually work, and what it is like to ship production services in it.</description>
    </item>
    
    <item>
      <title>Contact us</title>
      <link>https://buildfromzero.com/contact/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://buildfromzero.com/contact/</guid>
      <description> tom@buildfromzero.com </description>
    </item>
    
  </channel>
</rss>
