Skip to content

KandZ - Tuts

  • Operating Systems ▾
    • Linux ▾
      • Distros ▾
        • Fedora
        • Other Distros
        • Ubuntu
      • Gnome 48
      • KDE
      • LFCA - Linux Foundation Certified IT Associate
      • LFCS - Linux Foundation Certified Sysadmin
      • LFCE - Linux Foundation Certified Engineer (Sysadmin + Network Admin)
      • Linux CLI
      • Various
      • Bash Scripting
  • Paths ▾
    • Core Web Stack
    • React & Modern UI Stack
    • Linux Core
  • Programming ▾
    • Frontend (FED) ▾
      • React Ecosystem ▾
        • React
        • React Router
        • TanStack Router
        • TanStack Query (React Query)
        • Zustand
        • Redux Toolkit
      • Angular Ecosystem ▾
        • Angular
      • Vue Ecosystem ▾
        • Vue.js
      • Styling & UI Components ▾
        • Tailwind CSS
    • Languages & Runtimes ▾
      • CSS
      • Dart
      • HTML
      • JavaScript
      • Node.js
      • Rust
      • SQL
      • TypeScript
    • Tools & Build Systems ▾
      • Version Control ▾
        • GitHub
        • Git
        • GitLab
      • Package Managers ▾
        • npm
        • Bun
        • yarn
        • pnpm
      • DevOps & Containers ▾
        • Docker
  • Servers & Self-Hosting ▾
    • Internet ▾
      • Internet Backend - Coming Soon
      • Internet Beginner
      • Internet Frontend - Coming Soon
    • Networking & DNS ▾
      • REST API
  • Tools
  • Windows ▾
    • Windows 11
KandZ - Tuts
AngularBunCSSDartDockerGitGitHubGitLabHTMLJavaScriptNode.jsnpmpnpmReactReact RouterRedux ToolkitRustSQLTailwind CSSTanStack Query (React Query)TanStack RouterTypeScriptVue.jsyarnZustandBash ScriptingFedoraGnome 48KDELFCA - Linux Foundation Certified IT AssociateLFCE - Linux Foundation Certified Engineer (Sysadmin + Network Admin)LFCS - Linux Foundation Certified SysadminLinux CLIOther DistrosUbuntuVariousCore Web StackInternet Backend - Coming SoonInternet BeginnerInternet Frontend - Coming SoonLinux CoreReact & Modern UI StackREST APIToolsWindows 11
  • GitHub 07 🌐 Clones and Forks: Working with Remote Repositories
    Programming | GitHub | Tools & Build Systems

    GitHub 07 🌐 Clones and Forks: Working with Remote Repositories

    ByKandZ October 26, 2026October 26, 2026

    Cloning and forking are often confused because both create copies of a repository. But they operate in different places and serve different purposes. A clone is a local copy on your computer, created with git clone. A fork is a server-side copy on your GitHub account, created with the “Fork” button. The distinction matters because…

    Read More GitHub 07 🌐 Clones and Forks: Working with Remote RepositoriesContinue

  • GitHub 06 🌐 Pushing Local Code to GitHub (git remote and git push)
    Programming | GitHub | Tools & Build Systems

    GitHub 06 🌐 Pushing Local Code to GitHub (git remote and git push)

    ByKandZ October 26, 2026October 26, 2026

    A local Git repository is an island. Commits accumulate in the .git directory, branches are created and merged, but none of it is visible to anyone else until the repository is connected to a remote. git remote establishes that connection, and git push transmits the commits across it. For a new project, this is a…

    Read More GitHub 06 🌐 Pushing Local Code to GitHub (git remote and git push)Continue

  • LFCS 95 🐧 RAID with mdadm — Managing and Recovering
    Linux | Operating Systems | LFCS - Linux Foundation Certified Sysadmin

    LFCS 95 🐧 RAID with mdadm — Managing and Recovering

    ByKandZ October 26, 2026October 26, 2026

    An array that is created and forgotten is a liability. Drives fail, sectors go bad, and arrays silently degrade into a state where a second failure means total data loss. Managing an mdadm array is not about reacting to catastrophe—it is about routine monitoring, deliberate failure testing, and a recovery procedure that you have practiced…

    Read More LFCS 95 🐧 RAID with mdadm — Managing and RecoveringContinue

  • LFCS 94 🐧 RAID with mdadm — Creating Arrays
    Linux | Operating Systems | LFCS - Linux Foundation Certified Sysadmin

    LFCS 94 🐧 RAID with mdadm — Creating Arrays

    ByKandZ October 26, 2026October 26, 2026

    The previous chapter established the theory of RAID levels. This chapter translates that theory into practice. mdadm is the userspace tool that communicates with the Linux kernel’s multiple device (md) driver to assemble physical block devices into a logical RAID array. The command syntax is dense—a single invocation can specify the array name, RAID level,…

    Read More LFCS 94 🐧 RAID with mdadm — Creating ArraysContinue

  • LFCS 93 🐧 RAID — Concepts
    Linux | Operating Systems | LFCS - Linux Foundation Certified Sysadmin

    LFCS 93 🐧 RAID — Concepts

    ByKandZ October 26, 2026October 26, 2026

    Redundant Array of Independent Disks—RAID—is not a backup strategy. It is a method of combining multiple physical drives into a single logical unit to achieve one of three goals: increased performance, increased fault tolerance, or both. The LFCS exam expects you to understand the trade-offs between the common RAID levels and to recognize which level…

    Read More LFCS 93 🐧 RAID — ConceptsContinue

  • LFCS 92 🐧 Filesystem Repair — e2fsck, xfs_repair
    Linux | Operating Systems | LFCS - Linux Foundation Certified Sysadmin

    LFCS 92 🐧 Filesystem Repair — e2fsck, xfs_repair

    ByKandZ October 26, 2026October 26, 2026

    The previous chapter introduced the decision to run a repair. This chapter covers the tools themselves. e2fsck and xfs_repair are not interchangeable frontends for the same operation. They operate on different filesystem architectures, accept different flags, and enforce different preconditions. e2fsck assumes the filesystem may be dirty and performs a multi-pass check that can rebuild…

    Read More LFCS 92 🐧 Filesystem Repair — e2fsck, xfs_repairContinue

  • LFCS 91 🐧 Filesystem Integrity — fsck
    Linux | Operating Systems | LFCS - Linux Foundation Certified Sysadmin

    LFCS 91 🐧 Filesystem Integrity — fsck

    ByKandZ October 26, 2026October 26, 2026

    Filesystem corruption is not a theoretical concern. A sudden power loss, a failing disk, or an unclean shutdown can leave metadata in an inconsistent state—inodes marked as allocated with no directory entry, blocks claimed by multiple files, or a superblock that no longer matches reality. The fsck family of tools exists to detect and repair…

    Read More LFCS 91 🐧 Filesystem Integrity — fsckContinue

  • Rust 120 🦀 Low-Level Networking with Raw Sockets and Packet Processing
    Programming | Languages & Runtimes | Rust

    Rust 120 🦀 Low-Level Networking with Raw Sockets and Packet Processing

    ByKandZ October 26, 2026October 26, 2026

    The standard library’s TcpStream and UdpSocket abstract away the network layer. They handle IP headers, checksums, and routing. But when you need to craft a custom protocol, implement a diagnostic tool, or build a userspace TCP/IP stack, that abstraction becomes a barrier. Raw sockets bypass the kernel’s network stack, giving you direct access to the…

    Read More Rust 120 🦀 Low-Level Networking with Raw Sockets and Packet ProcessingContinue

  • Rust 119 🦀 Zero-Copy Parsing and Lifetime-Bound Deserialization (zerocopy / rkyv)
    Programming | Languages & Runtimes | Rust

    Rust 119 🦀 Zero-Copy Parsing and Lifetime-Bound Deserialization (zerocopy / rkyv)

    ByKandZ October 26, 2026October 26, 2026

    Traditional deserialization reads a byte buffer, parses its contents, and allocates new memory to reconstruct the data structure. Zero-copy deserialization skips that final step: the byte buffer is laid out so that it already is the in-memory representation, and the program simply casts a pointer into the buffer and reads fields directly. Rust’s type system…

    Read More Rust 119 🦀 Zero-Copy Parsing and Lifetime-Bound Deserialization (zerocopy / rkyv)Continue

  • Rust 118 🦀 Custom Async Executors and Polling Reactor/Waker Architecture
    Programming | Languages & Runtimes | Rust

    Rust 118 🦀 Custom Async Executors and Polling Reactor/Waker Architecture

    ByKandZ October 26, 2026October 26, 2026

    Rust’s standard library provides the Future trait, the Waker type, and the Context that ties them together. It does not provide an executor. Every async runtime in the ecosystem—Tokio, async-std, smol, and every educational implementation—builds these missing pieces from the same primitives. Understanding this architecture is not academic. When a future hangs, when a task…

    Read More Rust 118 🦀 Custom Async Executors and Polling Reactor/Waker ArchitectureContinue

Page navigation

Previous PagePrevious 1 … 28 29 30 31 32 … 257 Next PageNext
    Search