raft

An overview of the Raft consensus algorithm, explaining its key components including leader election and log replication. This post covers the basics of how Raft ensures consistency across distributed systems, handles network partitions, and maintains a replicated state machine.

全链路追踪的各种概念

An overview of distributed tracing concepts, including traces, spans, and contexts, with a focus on OpenTracing standards and their applications in system monitoring and debugging.

学习印尼语一个月总结

A summary of my experience learning Indonesian in one month, discussing the challenges and achievements, and providing insights into the learning process.

我的信息来源

记录信息来源, 持续修订

可复用的 UI 代码

string search algorithm #1: 暴力枚举和Boyer–Moore算法

An introduction to string search algorithms, focusing on the naive brute-force approach and the Boyer-Moore algorithm. This post explains the basic concepts, implementation details, and efficiency improvements of these methods for finding substrings within larger text.

sort/hash超出内存大小如何处理

An overview of out-of-core sorting and hashing techniques for handling datasets larger than available memory. This post explains buffer usage, the process of external sorting with multiple passes, and partitioning strategies for out-of-core hashing, including analysis of memory requirements and data size limitations.

如何用自定义 Linter 确保样式符合设计系统

用设计系统作为允许清单，通过自定义 Linter 约束 AI 生成代码的样式，保证颜色、间距、字体等符合规范。

JAVA repl 运行时添加 maven / clojure lib

RocketMQ 磁盘满处理方式

An explanation of how RocketMQ handles disk full scenarios, including the error message, relevant source code, and the disk space checking mechanism.

Kleisli

An introduction to Kleisli arrows in functional programming, explaining how they enable composition of functions that return monadic values. The post covers the concept of Kleisli composition, its implementation in Cats, and provides examples using the Writer monad.

virtual table

网络协议七层模型

An overview of the OSI and TCP/IP network models, explaining the functions of each layer and how they interact. This post also covers network topologies and protocols like CSMA and token ring used in bus networks.

free functor/monad

An exploration of natural transformations between functors in functional programming, introducing the concept of Free functors and demonstrating how to implement conversions between different container types like Monix Task, Scala Future, and Java CompletableFuture.

static site generator

Finding Fulfillment at Work

Exploration of common workplace dissatisfaction factors and practical approaches to enhance career fulfillment.

用 MessageChannel 和 iframe 通信

An explanation of how to use MessageChannel for bidirectional communication between a parent page and an iframe, with code examples and step-by-step instructions.

Lens part1 - Iso

An introduction to Iso, a type of lens in functional programming that represents isomorphisms between types. The post explains the concept, provides code examples in Scala, and demonstrates practical applications of Iso in handling unit conversions.

数据库的储存方式

An overview of database storage methods, including log-structured storage, indexing techniques, Sorted String Tables (SSTs), and B-trees. The post explores the advantages of each approach and discusses optimizations for improved performance and reliability.

ThirdTime 工作法使用一个月后的心得体会

A reflection on the experience of using the ThirdTime work method for one month, discussing the challenges and achievements, and providing insights into the work method.

clojure as framework

What Makes a Good Blog: Beyond Aesthetics and Technical Aspects

The concept of digital gardening, ideal navigation structures, and content update challenges

lens，函数式的getter和setter

An introduction to lenses in functional programming, explaining how they serve as functional equivalents to getters and setters in object-oriented programming, with code examples in Scala.

RocketMQ MQBrokerException: CODE: 14 问题排查

A detailed investigation of the MQBrokerException code 14 issue in RocketMQ, discussing the causes and solutions.

用clojure写个编译器, part1

A tutorial series on building a compiler in Clojure, starting with simple arithmetic expressions and progressing to more complex language features, including AST visualization and compilation to stack-based VM instructions.

RocketMQ 5.0 解锁任意时间延迟消息能力

An exploration of the new delay message feature in RocketMQ 5.0, discussing its implementation and how to set the precision parameter for optimal performance.

polymorphic function value 2

An exploration of polymorphic function values in Scala, focusing on natural transformations. This post discusses the limitations of standard Scala function values and introduces a more flexible approach for handling polymorphic functions, particularly useful for operations on heterogeneous lists (HLists).

本项目的 Tailwind 设计系统 Linter 实现

说明当前项目如何落地设计系统 Linter 方案的数据源与规则实现。

Many Java Codebases Are a Mess

Me rant about Java and Java devs

integrant repl

fault tolerence vm

An analysis of fault-tolerant virtual machine replication techniques, discussing primary-backup architectures, deterministic replay, output consistency, and failure detection mechanisms. The post also compares these approaches with log replication in the Raft consensus algorithm.

博客使用的技术栈

An overview of the technologies and tools used to create this blog, including Astro, MDX, React, Tailwind CSS, and more.

akka实现logical timestamp和分布式锁, part 1-1: 问题描述和总体框架

An implementation of a distributed mutex using Akka, exploring logical timestamps and consensus algorithms. This post introduces the problem, outlines the requirements for the distributed lock, and sets up the basic Akka actor structure for the solution.

out of core sorting, rust实现

A Rust implementation of out-of-core sorting algorithm, demonstrating how to handle datasets larger than available memory. This post covers the basic concepts of out-of-core sorting, explains the phased approach, and provides a step-by-step implementation in Rust, focusing on disk I/O operations and memory management.

Profunctor

An introduction to profunctors in functional programming, explaining their definition, relationship to bifunctors, and implementation in Scala. This post covers the basic structure of profunctors, their laws, and provides examples of profunctor instances like function types.

写作和写代码

Support My Writing Journey

it's like contribution.md on github, but for writing

The Benefits and Challenges of Shadowing

An exploration of shadowing as a language learning technique, discussing its effectiveness at different proficiency levels and providing practical tips for maximizing its benefits.

Decompose task

Strategies for Effortless and Impactful Writing

Discover practical techniques to make writing easier and more effective, including leveraging AI tools, personal note-taking systems, and identity-based habit formation for a more productive writing process.

applicative functor

An introduction to applicative functors in functional programming, explaining their definition, methods, and properties with Scala code examples. The post covers the ap and pure methods, as well as the product-based definition of applicatives.

database instead of file system

at most once

An explanation of how to implement at-most-once semantics in distributed systems, covering client-side XID usage, server-side result caching, and strategies for cache management and handling concurrent requests.

语言的边界就是我的世界

map reduce

An overview of the MapReduce distributed computing model based on the original Google paper. This post covers the MapReduce workflow, master-worker architecture, fault tolerance mechanisms, and optimization techniques like data locality and backup tasks. It also addresses common questions about task granularity and failure handling in MapReduce systems.

incremental UI

交换机，路由器等硬件

An overview of networking hardware including hubs, switches, and routers, along with traffic classification and packet capture techniques. This post explores the differences between these devices, their roles in network communication, and methods for monitoring network traffic.

GFS

An analysis of the Google File System (GFS) architecture, discussing its design assumptions, chunk-based storage, metadata management, and consistency model. The post explores the benefits and drawbacks of large chunk sizes, the role of the master server, and the system's approach to data mutations and consistency.

Contravariant Functor Intuition

An exploration of contravariant functors in functional programming, explaining their definition, intuition, and practical applications. The post covers the contramap function, compares it with covariant functors, and provides examples using Show and Ordering types in Scala.

nix