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
  • LFCS 96 🐧 Network Interfaces — ip addr
    Linux | Operating Systems | LFCS - Linux Foundation Certified Sysadmin

    LFCS 96 🐧 Network Interfaces — ip addr

    ByKandZ October 26, 2026October 26, 2026

    The ip command from the iproute2 suite has replaced the legacy ifconfig and route tools on virtually every modern Linux distribution. For the LFCS exam, ip addr is the essential tool for inspecting and modifying network interface addresses. The command operates on live kernel state, which means every change made with ip addr add or…

    Read More LFCS 96 🐧 Network Interfaces — ip addrContinue

  • Rust 131 🦀 Cheatsheet
    Programming | Languages & Runtimes | Rust

    Rust 131 🦀 Cheatsheet

    ByKandZ October 26, 2026October 26, 2026

    1. Toolchain & Cargo 2. Variables & Mutability 3. Primitives & Types 4. Strings 5. Ownership & Borrowing 6. Structs & Enums 7. Pattern Matching 8. Traits & Generics 9. Smart Pointers 10. Error Handling 11. Closures 12. Iterators 13. Threads & Concurrency 14. Unsafe & FFI 15. Lifetimes 16. Macros 17. Edition 2024 Changes…

    Read More Rust 131 🦀 CheatsheetContinue

  • Rust 130 🦀 Formal Verification and Theorem Proving in Rust (Kani / Prusti)
    Programming | Languages & Runtimes | Rust

    Rust 130 🦀 Formal Verification and Theorem Proving in Rust (Kani / Prusti)

    ByKandZ October 26, 2026October 26, 2026

    Testing shows the presence of bugs, never their absence. Fuzzing finds panics and crashes, but it cannot prove that a function returns the correct value for every possible input. Formal verification is the discipline of mathematically proving that a program satisfies a specification. For Rust, two tools occupy opposite ends of the verification spectrum. Kani…

    Read More Rust 130 🦀 Formal Verification and Theorem Proving in Rust (Kani / Prusti)Continue

  • Rust 129 🦀 Fuzzing Rust Codebases with cargo-fuzz and AddressSanitizer
    Programming | Languages & Runtimes | Rust

    Rust 129 🦀 Fuzzing Rust Codebases with cargo-fuzz and AddressSanitizer

    ByKandZ October 26, 2026October 26, 2026

    Fuzzing is the automated art of throwing malformed, mutated, and malicious inputs at a program until it breaks. In C and C++, a fuzzer’s goal is memory corruption: heap overflows, use-after-free, and out-of-bounds writes. In safe Rust, those specific bugs are impossible—the compiler eliminates them. But this does not make fuzzing irrelevant. It shifts the…

    Read More Rust 129 🦀 Fuzzing Rust Codebases with cargo-fuzz and AddressSanitizerContinue

  • Rust 128 🦀 Binary Analysis, Reverse Engineering Defense, and Stripping Symbols
    Programming | Languages & Runtimes | Rust

    Rust 128 🦀 Binary Analysis, Reverse Engineering Defense, and Stripping Symbols

    ByKandZ October 26, 2026October 26, 2026

    A compiled Rust binary is not a black box. The machine code can be disassembled, the data sections can be read, and the control flow can be reconstructed. For developers shipping proprietary algorithms, licensing logic, or security-sensitive code, this visibility is a liability. The defense is layered: stripping symbols removes the map that makes reverse…

    Read More Rust 128 🦀 Binary Analysis, Reverse Engineering Defense, and Stripping SymbolsContinue

  • Rust 127 🦀 High-Frequency Trading (HFT) Memory Management and Latency Optimization
    Programming | Languages & Runtimes | Rust

    Rust 127 🦀 High-Frequency Trading (HFT) Memory Management and Latency Optimization

    ByKandZ October 26, 2026October 26, 2026

    In high-frequency trading, latency is measured in nanoseconds, and memory allocation is the enemy. A single call to the system allocator can cost hundreds of nanoseconds—an eternity when competing orders are separated by microseconds. Rust’s ownership model and zero-cost abstractions make it a viable language for HFT, but the default allocator and standard data structures…

    Read More Rust 127 🦀 High-Frequency Trading (HFT) Memory Management and Latency OptimizationContinue

  • Rust 126 🦀 Distributed Systems Architecture and RPC Integration (tonic / gRPC)
    Programming | Languages & Runtimes | Rust

    Rust 126 🦀 Distributed Systems Architecture and RPC Integration (tonic / gRPC)

    ByKandZ October 26, 2026October 26, 2026

    A distributed system is a collection of independent computers that appears to its users as a single coherent system. The moment a Rust backend outgrows a single process, the communication layer becomes the critical path: it determines latency, failure behavior, and the shape of every service boundary. Remote Procedure Calls (RPC) abstract the network away,…

    Read More Rust 126 🦀 Distributed Systems Architecture and RPC Integration (tonic / gRPC)Continue

  • Rust 125 🦀 SIMD Vectorization (std::arch and wide crates)
    Programming | Languages & Runtimes | Rust

    Rust 125 🦀 SIMD Vectorization (std::arch and wide crates)

    ByKandZ October 26, 2026October 26, 2026

    Single Instruction, Multiple Data (SIMD) allows a CPU to process multiple values with a single instruction. On modern x86_64 processors, this means adding four f32 values in the time it takes to add one, or processing eight u8 values in a single operation. Rust provides two primary paths to SIMD: the std::arch module, which exposes…

    Read More Rust 125 🦀 SIMD Vectorization (std::arch and wide crates)Continue

  • Rust 124 🦀 Compiler Toolchain Targets, Cross-Compilation, and Linker Flags
    Programming | Languages & Runtimes | Rust

    Rust 124 🦀 Compiler Toolchain Targets, Cross-Compilation, and Linker Flags

    ByKandZ October 26, 2026October 26, 2026

    Rust’s default build path assumes the host machine and the target machine are the same. A standard cargo build compiles for the host architecture, links against the host’s C library, and produces a binary that runs on the machine that produced it. Cross-compilation breaks this assumption. The toolchain must be told which target to build…

    Read More Rust 124 🦀 Compiler Toolchain Targets, Cross-Compilation, and Linker FlagsContinue

  • Rust 123 🦀 Linux eBPF Program Development using Rust (aya framework)
    Programming | Languages & Runtimes | Rust

    Rust 123 🦀 Linux eBPF Program Development using Rust (aya framework)

    ByKandZ October 26, 2026October 26, 2026

    Extended Berkeley Packet Filter (eBPF) allows custom programs to run inside the Linux kernel without changing kernel source code or loading modules. For years, writing eBPF meant writing C and relying on libbpf and clang. The aya framework changes this: it is a pure-Rust library that lets you write both the kernel-side eBPF program and…

    Read More Rust 123 🦀 Linux eBPF Program Development using Rust (aya framework)Continue

Page navigation

Previous PagePrevious 1 … 26 27 28 29 30 … 257 Next PageNext
    Search