• 21 February 2026

    • MU Online in Rust: Hardening the Foundation, runtime, Timeouts, and Packet Size Limits

    Before diving into login and encrypted packets, we harden the server foundation. We introduce mu-runtime for generic TCP handling, implement read/write timeouts, and add max packet size enforcement to protect against slowloris and memory exhaustion attacks.

    rustnetworkmu-onlinefeatured
    15 min
    MU Online in Rust: Hardening the Foundation, runtime, Timeouts, and Packet Size Limits
  • 18 February 2026

    • From Nostalgia to Code: Building a MU Online Server in Rust

    Driven by nostalgia for MU Online, we use OpenMU as a reference to build a server from scratch in Rust. In this first episode, we decode the binary protocol, understand packet framing and encryption, explore the ConnectServer/GameServer architecture, and implement just enough to see the legendary login screen appear.

    rustnetworkmu-onlinefeatured
    29 min
    From Nostalgia to Code: Building a MU Online Server in Rust
  • 10 February 2026

    • OSDev Bare Bones with Rust - Cross-Compilation and Freestanding

    An introduction to OS development following the OSDev Bare Bones tutorial. We explore what cross-compilation and freestanding environments are, compile a C kernel with Zig, and set up a minimal Rust project targeting bare metal.

    rustcziglinuxfeatured
    20 min
    OSDev Bare Bones with Rust - Cross-Compilation and Freestanding
  • 20 February 2025

    • Rust Raw Pointers

    Learn about Rust's raw pointers.

    notesrust
    8 min
    Rust Raw Pointers
  • 20 February 2025

    • Rust PartialEq, Eq, PartialOrd and Ord

    Understanding Rust's Equality and Ordering Traits

    notesrust
    11 min
    Rust PartialEq, Eq, PartialOrd and Ord
  • 20 February 2025

    • Copy or Move?

    Learn about Rust's copy and move semantics.

    notesrust
    1 min
    Copy or Move?
  • 20 February 2025

    • Rust's Cell<T>

    Learn about Rust's Cell<T>.

    notesrust
    11 min
    Rust's Cell<T>
  • 20 February 2025

    • Golang Graceful Shutdown

    Learn about Golang's graceful shutdown.

    notesgo
    7 min
    Golang Graceful Shutdown
  • 20 February 2025

    • CS Float Representation

    Learn about the representation of floating-point numbers in computer science.

    notesengineeringrust
    13 min
    CS Float Representation
  • 20 October 2024

    • Playing with Rust: Building a Safer rm and Having Fun Along the Way

    In this post, I introduce rrm, a Rust-based command-line tool for safely managing deleted files, explore extended attributes, and share insights on using Rust's mockall crate for testing.

    rustlinuxyolopocfeatured
    13 min
    Playing with Rust: Building a Safer rm and Having Fun Along the Way
  • 29 June 2024

    • Fooling Port Scanners: Simulating Open Ports with eBPF and Rust

    Dive into the world of network security with this comprehensive guide on using eBPF and Rust to outsmart port scanners. This article explains the TCP three-way handshake, explores the popular Stealth SYN Scan technique, and demonstrates how to implement an eBPF program that simulates open ports.

    eBPFlinuxkernelrustfeatured
    20 min
    Fooling Port Scanners: Simulating Open Ports with eBPF and Rust
  • 21 June 2024

    • Networking and Sockets: Syn and Accept queue

    In this article, we delve into the mechanics of TCP connection management, focusing on the SYN queue and the accept queue. We explore backlog configurations, system parameters like net.core.somaxconn and net.ipv4.tcp_abort_on_overflow, and how they affect queue behavior.

    linuxrustsocketsnetworkfeatured
    12 min
    Networking and Sockets: Syn and Accept queue
  • 14 June 2024

    • Networking and Sockets: Endianness

    This article explores the concept of endianness in computer systems, focusing on how different byte orders (little-endian and big-endian) affect data interpretation in network communication. Through practical examples using Rust, we demonstrate the importance of handling endianness correctly when sending and receiving data between clients and servers.

    linuxrustsocketsnetwork
    17 min
    Networking and Sockets: Endianness
  • 7 June 2024

    • Getting Started with Networking and Sockets

    This article provides a comprehensive introduction to the fundamentals of socket programming using Rust and the nix crate. It starts with an overview of the OSI model and its practical application through the TCP/IP model, laying the groundwork for understanding network communication.

    linuxrustsocketsnetwork
    21 min
    Getting Started with Networking and Sockets
  • 20 May 2024

    • Turning Problems into Solutions: Provide Alternatives, Not Excuses

    This article emphasizes the importance of providing solutions instead of excuses in software engineering, promoting a proactive mindset.

    reflectionsengineering
    5 min
    Turning Problems into Solutions: Provide Alternatives, Not Excuses
  • 19 May 2024

    • The Broken Window in Software Projects

    Explore the 'Broken Window' theory in software development and how small, unaddressed issues can lead to significant technical debt.

    reflectionsengineering
    4 min
    The Broken Window in Software Projects
  • 10 February 2024

    • Go 1.22's HTTP Package Updates

    Discover the updates to the HTTP package in Go 1.22. This article covers how these changes make http services easier, including better routing and HTTP method management.

    goservices
    6 min
    Go 1.22's HTTP Package Updates
  • 21 December 2023

    • Simplified Networking: Crafting Isolated Echo Server with Rust

    In this blog post, we dive into the creation of 'isoserver', a simple yet effective program for setting up isolated servers with their own network namespaces in Rust.

    rustlinuxnetworkeBPF
    25 min
    Simplified Networking: Crafting Isolated Echo Server with Rust
  • 7 December 2023

    • Uprobes Siblings - Capturing HTTPS Traffic: A Rust and eBPF Odyssey

    In this engaging blog post, we embark on a journey to create a basic HTTPS sniffer using Rust and eBPF, focusing on the widely used OpenSSL library. Using uprobes for monitoring OpenSSL functions and capturing unencrypted data from SSL/TLS operations.

    eBPFlinuxkernelrust
    29 min
    Uprobes Siblings - Capturing HTTPS Traffic: A Rust and eBPF Odyssey
  • 21 November 2023

    • Harnessing eBPF and XDP for DDoS Mitigation: A Rust Adventure with rust-aya

    DDoS Mitigation with XDP and Rust: Dive into a Rust-based eBPF program for redirecting UDP flood attacks to a honeypot. This hands-on guide demonstrates the potent synergy of XDP and Rust in network security, offering a practical approach to packet manipulation and cybersecurity.

    eBPFlinuxkernelrust
    26 min
    Harnessing eBPF and XDP for DDoS Mitigation: A Rust Adventure with rust-aya
  • 8 November 2023

    • Beginner's Guide to XDP: A Journey Through Crafting XDP-Based Firewall with BCC

    Step into the world of eBPF/XDP with this beginner's guide. Learn to build a simple SSH firewall, utilizing XDP's capabilities for secure, incoming network traffic management!

    eBPFlinuxkernelpythonfeatured
    24 min
    Beginner's Guide to XDP: A Journey Through Crafting XDP-Based Firewall with BCC
  • 27 October 2023

    • Beyond Observability: Modifying Syscall Behavior with eBPF - My Precious Secret Files

    This article dives into a subtle application of eBPF, extending beyond its conventional use for observability to demonstrate its capability to modify system call behavior, showcased through a simple application designed to safeguard our precious files.

    eBPFlinuxkernelpythonfeatured
    11 min
    Beyond Observability: Modifying Syscall Behavior with eBPF - My Precious Secret Files
  • 22 October 2023

    • IPv4 Socket Surveillance - Tracing using kprobe, kretprobe and maps with BCC

    Through a simple app, this post illustrates real-time monitoring of network activities triggered by syscalls, utilizing kprobe, kretprobe, and maps. It highlights the synergy between eBPF and these probing tools, showcasing a practical approach to understanding network operations.

    eBPFlinuxkernelpythonfeatured
    20 min
    IPv4 Socket Surveillance - Tracing using kprobe, kretprobe and maps with BCC
  • 14 October 2023

    • The beginning of my eBPF Journey - Kprobe Adventures with BCC

    Embark on a fascinating journey into the realm of eBPF programming through this blog post. We kickstart our exploration with Kprobe, a dynamic tracing tool in the Linux kernel, by delving into a simple 'Hello World' and other experiment using BCC.

    eBPFlinuxkernelpythonfeatured
    19 min
    The beginning of my eBPF Journey - Kprobe Adventures with BCC
  • 30 January 2023

    • Rag with ChatGPT and ChromaDB for BG3 using Langchain

    In recent weeks, I've been delving into GenAI while also enjoying the fantastic game Baldur's Gate 3 (BG3).

    pocpythongenai
    3 min
    Rag with ChatGPT and ChromaDB for BG3 using Langchain
  • 30 January 2023

    • Optimizing Large File Transfers in Linux with Go - An Exploration of TCP and Syscall

    Explore efficient large file transfers in Linux using Go, focusing on minimizing data copies and context switches via the sendfile syscall.

    golinuxsocketsnetworkfeatured
    11 min
    Optimizing Large File Transfers in Linux with Go - An Exploration of TCP and Syscall
  • 19 December 2022

    • CEL for admission controller with ValidatingAdmissionPolicy in K8s 1.26

    Explore enhancing Kubernetes cluster security with the Common Expression Language (CEL) for creating fine-grained admission control policies in K8s 1.26, including setup and policy binding instructions​.

    k8s
    10 min
    CEL for admission controller with ValidatingAdmissionPolicy in K8s 1.26
  • 16 December 2022

    • A simple example of using unix domain socket in Kubernetes

    Discover using Unix domain sockets in Kubernetes for inter-container communication within a pod, illustrated with Go applications. Gain insights into setup, benefits like faster communication, and testing the deployment​.

    golinuxsocketsnetworkk8s
    6 min
    A simple example of using unix domain socket in Kubernetes
  • 5 December 2022

    • Understanding Unix Domain Sockets in Golang

    Delve into the workings of Unix domain sockets in Golang, contrasting them with network sockets. Explore their creation, efficient inter-process communication on the same machine, and practical code examples demonstrating a simple echo server setup​.

    golinuxsocketsnetworkfeatured
    11 min
    Understanding Unix Domain Sockets in Golang
  • 21 April 2022

    • My introduction to the Blockchain and Merkle Tree

    Embark on a journey through Blockchain's core, exploring its enticing realm with a dive into Merkle trees. This piece illuminates the path from a gaming intrigue to developing a Go-based Merkle tree, underlining Blockchain's cryptographic elegance and data integrity verification. A must-read for the crypto-curious coder.

    blockchaingodata structure
    14 min
    My introduction to the Blockchain and Merkle Tree
  • 21 August 2021

    • Socket sharding in Linux example with Go

    Uncover socket sharding in Linux using Go, enabling multiple sockets to bind to the same IP and port for enhanced load balancing. The article provides insights into setting the SO_REUSEPORT socket option, creating a ListenConfig instance in Go.

    linuxgosocketsfeatured
    8 min
    Socket sharding in Linux example with Go
  • 1 March 2021

    • Implementing a simple K8s admission controller in Go

    Dive into implementing a Kubernetes admission controller in Go, governing cluster usage by intercepting API requests pre-persistence. Explore setup, webhook registration, and server creation, alongside simple validation/mutation use cases, for better cluster governance and security​.

    gok8s
    13 min
    Implementing a simple K8s admission controller in Go
  • 6 April 2020

    • How to setup simple load balancing with IPVS, demo with docker

    Explore setting up simple IPVS load balancing on Linux with a hands-on Docker demo, covering tool installation, virtual service creation, and verification.

    k8snetworklinuxfeatured
    6 min
    How to setup simple load balancing with IPVS, demo with docker
  • 29 October 2019

    • How BigCache avoids expensive GC cycles and speeds up concurrent access in Go

    Uncover how BigCache in Go alleviates expensive GC cycles and bolsters concurrent access, using sharding for data distribution and byte arrays to minimize GC interference, enhancing cache performance and application responsiveness.

    gofeatured
    10 min
    How BigCache avoids expensive GC cycles and speeds up concurrent access in Go
  • 21 July 2019

    • Implementation of Dijkstra using heap in Go

    Dive into implementing Dijkstra's Algorithm using a min-heap in Go, focusing on the creation of a priority queue to efficiently find the shortest path between nodes. The guide includes detailed code for heap and graph logic, demonstrating a practical approach to Dijkstra's Algorithm in Go.

    goalgorithmdata structurefeatured
    8 min
    Implementation of Dijkstra using heap in Go
  • 30 June 2019

    • Capturing logs and send them in an email with Go

    Simple demo about how to capture logs and send them in an email.

    go
    5 min
    Capturing logs and send them in an email with Go
  • 12 January 2019

    • Let's talk about Health Checks

    Explore health checks in microservices, covering their importance, implementation, and practical examples, ensuring service availability and proper functioning even in cloud-hosted scenarios, illustrated with a Redis-dependent service example​.

    goservicesredis
    6 min
    Let's talk about Health Checks
  • 5 October 2018

    • Tracking Service with Go and Redis V2

    Explore an upgraded tracking service using Go and Redis, designed to efficiently locate drivers. Utilizes Go's Goroutines, Channels, and time.Ticker struct for task execution, ensuring a single client request suffices to initiate a driver search task, thus enhancing user experience and reducing redundant requests.

    goredisservices
    18 min
    Tracking Service with Go and Redis V2
  • 9 August 2018

    • Tracking Service with Go and Redis

    Delve into creating a tracking service using Go and Redis for saving and processing driver locations similar to Uber, focusing on geospatial functions of Redis.

    goredisservices
    12 min
    Tracking Service with Go and Redis
  • 10 July 2018

    • Oauth2 with Google in Go

    Authentication is the most common part in any application. You can implement your own authentication system or use one of the many alternatives that exist, but in this case we are going to use OAuth2.

    go
    11 min
    Oauth2 with Google in Go
    rocket

    © 2023 KungFuDev made with love / cd 💜

    Heavily inspired/copied from shuttle.rs