Skip to main content Link Menu Expand (external link) Document Search Copy Copied
Rowan
  • Trang chủ
  • AWS Machine Learning (MLA-C01)
    • 1. AWS Services
      • 1.1 AI Services
      • 1.2 Generative AI & Foundation Models
      • 1.3 Machine Learning Algorithms
      • 1.4 Data Services for ML
    • 2. Core ML
      • 2.1 ML Fundamentals
      • 2.2 Feature Engineering
      • 2.3 Huấn luyện & Đánh giá Mô hình
    • 3. SageMaker
      • 3.1 Amazon SageMaker
      • 3.2 Algorithm Hyperparameters
      • 3.3 Training & Fine-Tuning
      • 3.4 SageMaker JumpStart
      • 3.5 Amazon SageMaker Clarify
    • 4. MLOps
      • 4.1 MLOps & Deployment
      • 4.2 Experiment Tracking & Versioning
      • 4.3 CI/CD & Model Registry
      • 4.4 Model Monitoring & Observability
    • 5. Security
      • 5.1 ML Security
      • 5.2 Encryption
      • 5.3 Network Security
    • 6. Guides
      • 6.1 Hướng dẫn Ôn thi AWS MLA
      • 6.2 Cheat Sheet
      • 6.3 [Tên Chủ đề]
  • Data Structures and Algorithms (DSA)
    • Phần 1
      • Chương 1 - Array
      • Chương 2 - String
      • Chương 3 - Recursion
      • Chương 4 - Sorting
      • Chương 5 - Binary Search
      • Chương 6 - Hash Table
    • Phần 2
      • Chương 7 - Linked List
      • Chương 8 - Queue + Stack
      • Chương 9 - Graph
      • Chương 10 - Breadth-First Search (BFS)
      • Chương 11 - Depth-First Search (DFS)
      • Chương 12 - Island Matrix Traversal
    • Phần 3
      • Chương 13 - Topological Sort
      • Chương 14 - Interval
      • Chương 15 - Heap
      • Chương 16 - Greedy
      • Chương 17 - Divide and Conquer
      • Chương 18 - Monotonic Queue + Stack
    • Phần 4
      • Chương 19 - Prefix Sum
      • Chương 20 - Prime Number
      • Chương 21 - Bit Manipulation + Mask
      • Chương 22 - Advanced Tree (BST, Segment Tree, Fenwick Tree)
      • Chương 23 - Trie
      • Chương 24 - Union Find (Disjoint Set Union)
    • Phần 5
      • Chương 25 - Advanced Binary Search (Search on Answer)
      • Chương 26 - Two Pointers (Fast & Slow Pointer)
      • Chương 27 - Sliding Window
      • Chương 28 - Backtracking
      • Chương 29 - Dynamic Programming
      • Chương 30 - Dijkstra
    • Phần 6
      • Chương 31 - Game Theory
      • Chương 32 - String Parser (Stack, State Machine, Regex)
      • Chương 33 - Minimum Spanning Tree (MST)
      • Chương 34 - Rolling Hash
      • Chương 35 - KMP (Knuth–Morris–Pratt)
    • Phần 7
      • Chương 36 - Z Function
      • Chương 37 - Binary Search kết hợp Graph Traversal
      • Chương 38 - Binary Search kết hợp Dynamic Programming
      • Chương 39 - Sorting kết hợp Dynamic Programming
      • Chương 40 - Bitmask Dynamic Programming
    • Phần 8
      • Chương 41 - Bitmask kết hợp Trie
      • Chương 42 - Tree Dynamic Programming
      • Chương 43 - Topological Sort kết hợp Dynamic Programming
      • Chương 44 - Combinatorics kết hợp Dynamic Programming
      • 🎉 Hết phần Level 3!
      • Phụ lục
  • Lập trình Rust
    • Dự án 1: Trình chuyển đổi Markdown sang HTML (CLI)
      • Khởi tạo Project Rust mới với Cargo
      • Read Input File Content in Rust
      • Create a Rust Parser Module for Code Organization
      • Create a Private Helper for Inline Parsing
      • Create an HTML Document Generator Function
      • Create a Test Module in Rust
      • Create a CSS Stylesheet for HTML Output
      • Add 'notify' Crate for File Watching in Rust
    • Dự án 2: Log File Analyzer
      • Initialize Rust Project with Cargo
      • Create the Parser Module File
      • Import clap::Parser Trait in Rust
      • Rust File I/O: Opening a File with `std::fs`
      • Implement a Statically Compiled Regex for Log Parsing
      • Initialize HashMaps for Log Data Aggregation
      • Convert a HashMap to a Sortable Vec in Rust
      • Displaying a Formatted Report Title in Rust
      • Create a New Rust Module for Statistics
      • Add Serde Dependencies for JSON Serialization in Rust
      • Create a Test Module for the Rust Parser
    • Dự án 3: Rust Quiz Game
      • Setting Up a Rust Project
      • Rust Quiz Game Implementation
      • Implementing User Input Handling in Rust Quiz Game
      • Designing a Scoring System for Rust Quiz Game
      • Displaying Quiz Results in Rust
      • Enhancing Rust Quiz with Multiple Question Types
      • Implementing Numeric Input Validation in Rust
      • Implement High Score System with Persistence in Rust
    • Dự án 4: File Organizer
      • Explaining Rust Standard Library Imports
      • File Extension Type Mapping
      • Defining Directory Names for File Organization
      • Determining File Types in Rust
      • Handling Errors with Result Types in Rust
      • Creating Test Files for File Organizer
    • Dự án 5: Random Password Generator
      • Password Length Input Validation in Rust
      • Generate Random Characters from Specified Sets in Rust
      • Password Length Validation Implementation
      • Printing a Generated Password to the Console in Rust
      • Adding Option to Exclude Ambiguous Characters in Rust Password Generator
    • Dự án 6: Peer-to-Peer File Sharing CLI
      • Initialize a Rust Project with Cargo
      • Add Serde and Bincode for Data Serialization
      • Create a new module for the sender logic (`sender.rs`).
      • Create the Receiver Module in Rust
      • Declare Sender and Receiver Modules in Rust
      • Add the `indicatif` crate to `Cargo.toml`.
      • Add a `discover` Subcommand for LAN Discovery
      • Create a Custom Error Enum for Robust Error Handling in Rust
      • Add doc comments (`///`) to all public functions and structs explaining their purpose.
    • Dự án 7: Terminal-Based Text Editor
      • Create a New Rust Project with Cargo
      • Implement the Main Event Loop
      • Define the Central Editor State Struct
      • Create the `refresh screen` Method for the Editor
      • Detecting Arrow Key Presses in a Rust Terminal Editor
      • Capture Character Input in Rust TUI Editor
      • Handle the 'Enter' Key Press in the Event Loop
      • Accept a Filename from the Command Line
      • Modify `refresh screen` to only draw text rows up to `screen rows - 1`.
      • Add `row offset` to Editor State for Viewport Scrolling
      • Implement Text Search Entry Point in Rust Editor
      • Refactor Editor Struct into a Separate Rust Module
    • Dự án 8: Concurrent Web Scraper
      • Create a New Rust Project with Cargo
      • Define a Public Product Struct in Rust
      • Define an Asynchronous Web Scraping Function in Rust
      • From a Single URL to a Vector of URLs
      • Create a Tokio MPSC Channel for Concurrent Scraper Results
      • Define the Output CSV Filename in a Rust Scraper
      • Update `scrape page` Function Signature for Pagination
      • Add `clap` Dependency for Command-Line Interface
      • Add a Delay Argument for Polite Scraping
      • Refactor Rust Code into a CLI Module
    • Dự án 9: Weather CLI Tool
      • Configuring API Key Storage for Weather CLI Tool
      • Parsing Command-Line Arguments for Location in Rust
      • Constructing Weather API URL in Rust
      • Parsing JSON Responses in Rust for Weather CLI Tool
      • Researching Additional Weather APIs for Rust Weather CLI Tool
      • Adding Unit Measurement Option to Rust Weather CLI
      • Implement Location Validation in Rust Weather CLI Tool
      • Adding Configuration Options for Default Location and Units in Rust
    • Dự án 10: Personal Finance Tracker
      • Implementing Transaction Struct in Rust
      • Adding a Transaction in Rust
      • Writing Transactions to CSV in Rust
      • Calculate Total Income in Rust
      • Implementing a Menu System in Rust for Personal Finance Tracker
      • Implementing Error Handling for File Operations in Rust
      • Documenting Rust Code with Rustdoc
    • Dự án 11: Rust Tic-Tac-Toe
      • Setting Up the Game Board in Rust Tic-Tac-Toe
      • Player Input Validation in Rust Tic-Tac-Toe
      • Winning Condition Check in Rust Tic-Tac-Toe
      • Clear Console and Redraw Board in Rust
      • Player Scoring System Implementation in Rust Tic-Tac-Toe
    • Dự án 12: WebAssembly 2D Game Engine
      • Install wasm-pack for Rust and WebAssembly Development
      • Accessing the HTML Canvas from Rust and WebAssembly
      • Integrate Bevy ECS for Game Architecture
      • Create the RenderingSystem Function Skeleton
      • Define an ECS Resource for Keyboard Input State
      • Add wasm-bindgen-futures for Asynchronous Web APIs
      • Create an `AudioManager` resource.
      • Implement a Collider Component for Collision Detection
      • Set Up the Initial Scene for a Pong Game
      • Game Engine: Implement the Rotation Component
      • Profiling a Rust and WebAssembly Game
    • Dự án 13: Distributed Key-Value Store
      • Create a New Rust Project with Cargo
      • Define the Network Request Protocol with a Rust Enum
      • Implement Command-Line Configuration with `clap`
      • Raft Consensus: Define Node States with a Rust Enum
      • Define Raft Log Entry and Command Structures in Rust
      • Create a CLI Client using a Second Binary Target in Rust
      • Choose a file format for the log (e.g., a simple binary format using `bincode`).
      • Add Tracing Dependencies for Observability
    • Dự án 14: Procedural Macro for Custom `derive`
      • Create a Rust Library Crate with Cargo
      • Remove Boilerplate Code from `src/lib.rs`
      • Parse Macro Input into an AST with `syn`
      • Extract Struct Identifier in a Rust Procedural Macro
      • Construct the name for the builder struct, typically by appending 'Builder' to the original struct's name (e.g., `Command` -> `CommandBuilder`).
      • Generate the Builder's `impl` Block
      • Define the `build()` Method Signature for the Builder Macro
      • Generate an `impl` Block for the Original Struct
      • Add `trybuild` as a `dev-dependency` in your `Cargo.toml`.
      • Rust Procedural Macro: Detect Optional Field Types
      • Change the return type of the generated `build` method to `Result<#original struct name, String>`.
      • Add Documentation to a Rust Procedural Macro
    • Dự án 15: Concurrent Network Server
      • Setting Up a TCP Listener in Rust
      • Implementing TCP Listener in Rust
      • Implementing TCP Listener in Rust
      • Choosing Between Async/Await or Threading Model for Concurrent Network Server
      • Implementing SSL/TLS Support for Secure Connections
    • Dự án 16: Ray Tracer
      • Implementing a 3D Sphere Struct in Rust
      • Implementing the Ray Struct in Rust for Ray Tracing
      • Ray-Sphere Intersection Calculation
      • Implement Basic Shading for Objects in Ray Tracer
      • Adding Multiple Materials to Ray Tracer
    • Dự án 17: Fractal Generator
      • Choosing a Graphics Library for Your Rust Fractal Generator
      • Implement Mandelbrot Set Calculation in Rust
      • Setting Up OpenGL Shaders for Fractal Rendering
      • Implement Mouse Panning in Fractal Generator
    • Dự án 18: LLVM-based Compiler for a Simple Language
      • Install the LLVM 15 Toolchain
      • Define Primitive Types for the SimpliLang Compiler
      • Define the Lexical Token Enum in Rust
      • Define Abstract Syntax Tree (AST) Nodes in Rust
      • Implement a Scope-Aware Symbol Table for Semantic Analysis
      • Implement the Core `CodeGen` Struct for LLVM Backend
      • Understanding Core LLVM Optimization Passes
      • Compiler Backend: Initialize Native Target
      • Define the Core Compiler CLI Struct with clap
      • Integrate an error-reporting crate like `ariadne` or `codespan-reporting`.
    • Dự án 19: Simple Operating System Kernel
      • Install and Configure Rust Nightly Toolchain for OS Development
      • Create a Freestanding Rust Binary for a Kernel
      • Integrate the x86 64 Crate for CPU Exception Handling
      • Add `pic8259` Crate for Hardware Interrupt Handling
      • Implement the Timer Interrupt Handler
      • Read and Print the Physical Memory Map
      • Implement a `FrameAllocator` using the bootloader's memory map (e.g., a bitmap allocator).
      • Define the Core Task Struct for Kernel Multitasking
      • Create a static buffer to store keyboard input.
    • Dự án 20: Async Task Executor
      • Choosing the Right Async Runtime for Your Rust Project
      • Implement Round-Robin Task Scheduling Algorithm
      • Choosing a Data Structure for the Task Queue in Rust
      • Implementing Task Status Tracking in Rust Async Task Executor
      • Implementing Task Prioritization in Async Task Executor
    • Dự án 21: Custom Compression Library
      • Researching Compression Algorithms for Custom Compression Library
      • Data Structure Design for Custom Compression Library
      • Implement Decompression Function for RLE + Huffman Coding
      • Creating Test Cases for Custom Compression Library
    • Dự án 22: Rust Programming Language Interpreter
      • Specifying Valid Data Types for Your Rust Language Interpreter
      • Writing Regular Expressions for Lexer Tokenization in Rust
      • Choosing a Parsing Algorithm for Rust Interpreter
      • Implementing a Runtime Environment in Rust
This site uses Just the Docs, a documentation theme for Jekyll.
  1. AWS Machine Learning (MLA-C01)
  2. 5. Security

Lên đầu trang

This site uses Just the Docs, a documentation theme for Jekyll.