whoway Technical Notes

website·Indexed 29 days ago

https://whoway.xyz

A collection of technical guides and notes covering Bash scripting, C++ data structures and algorithms (including DP, DFS/BFS, and sorting), network protocol analysis using tools like Wireshark, tcpdump, Charles, and nmap, and web server configuration focusing on Nginx and php-fpm.

Tokens
112.4K
Snippets
505
Records
742
Agent score
41%

What's inside whoway

  1. Overview of Markdown enhancements in VuePress Theme Hope

    VuePress generates pages from Markdown files using markdown-it. Theme Hope extends this functionality through two primary layers: standard VuePress enhancements and additional theme-specific enhancements provided by the vuepress-plugin-md-enhance plugin. These extensions allow for richer content including interactive components, charts, and advanced layout options.
  2. Overview of Monotonous Queue applications

    A Monotonous Queue maintains elements in a monotonically increasing or decreasing order. It allows deletions from both ends but insertions only at the tail. A key property is that each element enters and leaves the queue exactly once.

    Common applications include:

    • Sliding Window Maximum/Minimum (e.g., LeetCode 239).
    • Finding the minimum/maximum in a sliding window of a sequence.
  3. Overview of Essential Sorting Algorithms

    Sorting algorithms are categorized into five main types based on their underlying logic. Understanding these is critical for solving algorithmic problems (e.g., LeetCode 912) without using built-in functions.

    • Insertion-based: Direct Insertion Sort, Binary Insertion Sort, Shell Sort.
    • Selection-based: Simple Selection Sort, Heap Sort (focuses on the Heap data structure).
    • Exchange-based: Bubble Sort, Quick Sort (focuses on dual-pointer and divide-and-conquer techniques).
    • Merge-based: 2-way Merge Sort (focuses on space-time trade-offs).
    • Non-comparison based: Radix Sort, Counting Sort, Bucket Sort.
  4. Overview of Dynamic Web Service Evolution

    The evolution of web development is characterized by how requests enter a program, how programs persist in memory, and how resources are reused. This evolution is divided into three main stages:

    1. CGI (Common Gateway Interface): The starting point where the Web Server forks a new process for every request to execute a script.
    2. Containerization (FastCGI / Servlets): Introduction of long-running processes or containers using thread pools to handle requests, reducing the overhead of process creation.
    3. Application as Server: The application, framework, and runtime are bundled together (e.g., Spring Boot, Gin), where the application itself acts as the server.
    # Stage 1: CGI
    Web Server → fork process → execute script → stdout return
    
    # Stage 2: Containerization
    Web Server → Long-running process/container → thread pool
    
    # Stage 3: Application as Server
    Application = Web Server + Framework + Runtime
  5. Overview of VuePress theme-hope layout components

    The VuePress theme-hope layout consists of global elements and page-specific components that can be customized via theme options and page frontmatter.

    Global Layout Elements:

    • Navbar
    • Sidebar
    • Footer

    Page-Specific Elements:

    • Breadcrumbs
    • Page Title and information
    • Table of Contents (TOC)
    • Meta information (update time and contributors)
    • Comments section

    Interface Elements:

    • Dark Mode toggle button
    • Back to top button
    • Print button
  6. Apply Context Isolation in Multi-Agent systems

    Context Isolation separates the context windows between different agents. In a multi-agent architecture, each sub-agent maintains its own dedicated context window, allowing for a 'separation of concerns' and preventing one agent's noise from interfering with another's task.
  7. Understand the 'Application as Server' architecture paradigm

    In the modern 'Application as Server' paradigm, the Web Server is no longer a separate external entity that manages the application; instead, the application itself becomes the primary subject. This is characterized by embedded web servers where starting the application automatically begins listening on a network port. This approach is highly optimized for containerization, cloud-native deployments, and microservices due to its smaller granularity and DevOps-friendly nature.
    # Examples of starting applications that act as their own servers
    java -jar app.jar
    ./server
    uvicorn main:app
  8. Locate Wireshark internal configuration and plugin files

    To find the physical paths of Wireshark's internal files, including configuration files, plugin directories, and shortcut key definitions, check the 'Settings' (or About/Information) section of the application to view the specific file paths used by the installation.
  9. Understand the core pillars of LLM application development

    Most AI application technologies based on Large Language Models (LLMs) can be distilled into two fundamental components: Prompt Engineering and Context Engineering.

    • Prompt Engineering: The art of how to 'ask' the AI. It determines the starting point and direction of the AI's reasoning.
    • Context Engineering: The process of 'feeding' and 'managing' the AI's memory. This is critical for achieving professionalism and continuity in specific tasks, involving the organization, retrieval, updating, and limitation of background information within the AI's context window.
  10. Compare Web Service architecture paradigms (CGI vs Servlet vs Application-as-Server)

    The evolution of dynamic web services can be categorized into three distinct architectural paradigms based on their core subject, deployment unit, concurrency model, and isolation method:

    • CGI: The Web Server is the core subject. It deploys scripts and uses OS process isolation with a process-based concurrency model.
    • Servlet: The Container is the core subject. It deploys WAR files and uses ClassLoader isolation with a thread-pool concurrency model.
    • Application as Server: The Application itself is the core subject. It deploys as a JAR or binary and uses process/thread/coroutine-level isolation with a thread or coroutine concurrency model.
  11. Understand the 'Application as Server' architectural paradigm

    In the modern 'Application as Server' paradigm, the Web Server is no longer a separate external entity that manages the application; instead, the application itself becomes the primary subject. This is characterized by embedded web servers where starting the application automatically opens the listening port, making it highly suitable for containerization, cloud-native deployments, and microservices. Common examples include Spring Boot, Gin, and FastAPI.
    # Examples of starting applications that act as their own servers
    java -jar app.jar
    ./server
    uvicorn main:app