DOCSEARCHbyAlgolia
Submit Docs

Chanjunren's Zettelkasten

website·Indexed 30 days ago

https://chanjunren.github.io/

A personal knowledge base covering a diverse range of topics including software infrastructure (Kubernetes, Prometheus, Docker, distributed systems), programming paradigms, speed slalom skating techniques and training, finance, and interior design.

Tokens
309.4K
Snippets
873
Records
2.3K
Agent score
74%

What's inside Chanjunren Zettelkasten

  1. Overview of Hologres Real-Time Data Warehouse

    Hologres is a unified real-time data warehouse designed for large-scale data processing and analysis. It is fully compatible with PostgreSQL, allowing the reuse of PostgreSQL-based tools and queries. It is optimized for real-time analytics, marketing profiling, audience grouping, fine-grained self-service BI, and real-time risk management.

  2. Overview of Elasticsearch Compound and Leaf Query Clauses

    Elasticsearch queries are divided into Compound and Leaf clauses:

    Compound Query Clauses: Used to combine other clauses or alter behavior (e.g., bool, dis_max).

    • must: Logical AND
    • must_not: Logical NOT
    • should: Logical OR

    Leaf Query Clauses: These are the basic building blocks that look for a specific value in a specific field. Common leaf queries include:

    • match: Full-text search
    • term: Exact value search
    • range: Values within a range
    • exists: Checks if a field exists
    • prefix: Matches documents starting with a specific prefix
    • ids: Matches specific document IDs
    • fuzzy: Matches terms similar to the provided term

  3. Introduction to Docker Compose

    Docker Compose is a tool for defining and running multi-container applications using a declarative YAML configuration file. It allows developers to start an entire application stack—including dependencies, networks, and volumes—with a single command, replacing the need to manually run long docker run commands for each individual service.

  4. Overview of the Iron Condor options strategy

    An Iron Condor is a neutral, defined-risk income strategy designed to profit from range-bound stock movement. It is constructed by selling both an out-of-the-money (OTM) put spread and an OTM call spread with the same expiration date. The strategy generates profit from time decay (theta) and volatility contraction (vega) when the underlying asset trades sideways.

  5. Overview of MVEL expression language

    MVEL is a scripting language designed to be embedded within Java applications to perform simple scripting tasks. Key features include inline parsing (executing expressions directly within Java code), dynamic typing for reduced verbosity, and support for code generation, making it suitable for template engines and rule engines.

  6. Overview of Docker Swarm Architecture

    Docker Swarm is a built-in clustering and orchestration tool that transforms a group of Docker hosts into a single virtual host. It allows developers to define a desired state (e.g., replica count) and ensures the cluster maintains that state. It uses the same CLI and compose file format as standard Docker, making it a low-learning-curve alternative to Kubernetes for small-to-medium deployments (< 100 nodes).

  7. Overview of picom X11 compositor

    picom is a compositor for X11 that sits between Xorg and the window manager. It provides GPU-accelerated rendering via the GLX backend to prevent screen tearing and enables visual enhancements such as shadows, transparency, and blur, which are not built into X11.

  9. Overview of Grafana Alloy

    Grafana Alloy is a unified telemetry collector for metrics, logs, traces, and profiles. It is the successor to Grafana Agent (which reaches End-of-Life in November 2025). Alloy is an OpenTelemetry Collector distribution with built-in Prometheus pipelines, utilizing a component-based architecture and a programmable configuration language called River. It is designed to be vendor-neutral while maintaining Prometheus compatibility and providing native Kubernetes support.

  10. Overview of Apache SkyWalking APM

    Apache SkyWalking is an open-source application performance monitoring (APM) system designed for distributed systems, microservices, cloud-native architectures, and containerized environments (such as Kubernetes). It serves as a health check and diagnostic tool to provide insights into application performance, service interactions, and the root causes of slowdowns or errors.

  11. Overview of Data Processing Architectures

    Data processing architectures define the end-to-end flow of data—from collection and processing to storage and analysis. The primary goal is to ensure that the transition from raw input to final insights is efficient, scalable, and reliable. Common architectural patterns include:

    • Batch Processing: Focused on processing large blocks of data (e.g., ETL - Extract, Transform, Load).
    • Streaming Processing: Focused on real-time data flows (e.g., Kappa Architecture).
    • Hybrid Architectures: Combining both batch and streaming capabilities (e.g., Lambda Architecture).
    • Data Lake Architectures: Centralized repositories for storing vast amounts of raw data in its native format.

  12. Overview of Caching Patterns and Failure Modes

    Caching implementation involves selecting a core pattern, understanding its associated failure modes, and utilizing supporting data structures for mitigation.

    Core Patterns:

    • Cache-Aside: The production default; application-driven and robust.
    • Read-Through / Write-Through / Write-Back: Alternatives where the cache layer participates directly in the write/read process.

    Common Failure Modes:

    • Cache Penetration, Breakdown, and Avalanche: Three distinct classes of cache failure.
    • Cache Stampede (Thundering Herd): Mitigated via single-flight, refresh-ahead, or probabilistic early refresh.

    Supporting Tools:

    • Bloom Filters: Used as a probabilistic membership gate to prevent cache penetration.
    • Distributed Locks (e.g., Redis): Used for coordination, often involving fencing tokens to handle concurrency.