I'm Tide, and I've had PRs merged into redis/go-redis (22k★), go-task/task (16k★), and uber/kraken (6.7k★). I'm a Communication Engineering undergrad at Xiamen University (Class of 2028). I started with C++, then moved to Go for backend and open-source work; I build my own projects to learn. Lately, I've been building up cloud-native and platform engineering, and looking for a Go backend internship.

● Now
Last updated: Nov 2026
  • Contributing to uber/kraken and other Go open-source projects — when something looks broken, I reproduce it locally first.
  • Learning cloud-native and platform engineering — my direction is Go backend + cloud-native.
  • Iterating on orangecode, my open-source Agent Harness project.
Projects
orangecode — tui · live capture
orangecode terminal UI, live capture: the main screen, with the ORANGE CODE banner, session history panel, and status bar

orangecode

An Agent Harness that runs multiple tasks at once — and remembers the context.

An open-source agent harness for concurrent tasks and multi-turn conversations. It organizes task execution with Spine semantics, routes context via KNN semantic routing, and tracks per-call costs with CostLedger. Session exports carry SHA-256 signatures — verifiable and tamper-proof.

PythonTypeScriptAgent Harness
GitHub repo ↗
Publish
posting a video
→
Distribution
push–pull hybrid
→
Consumption
paginated feed
→
Interaction
likes & favorites, counted
→
Notifications
async queue

gorangefeed

What happens between a short video being posted and it showing up in your feed.

A short-video feed backend spanning publishing → distribution → consumption → interaction → notification. Structured around vertical slices, each stage its own module; split at runtime into a monolithic API and standalone workers, with time-consuming work like notifications routed through asynchronous queues so the request path stays unblocked.

GoGinMySQLRedisRabbitMQ
GitHub repo ↗
Enqueue
same transaction as the business row
→
Claim
fencing token blocks duplicate execution
→
Execute
local handler
→
Done
confirmed on success
On failure, retries back off exponentially; past the limit, tasks go to a dead-letter queue. If a worker dies mid-run, another worker picks its tasks up once the lease expires.

gorangetask

Tasks written to MySQL don't get lost — if a worker dies, another one picks them up.

An embeddable MySQL transactional task queue for Go services: business data and task rows are written in the same transaction, so once it commits, nothing is lost. Claiming runs on leases plus fencing tokens, so late writes from an old worker get rejected; failures retry with exponential backoff and land in a dead-letter queue once exhausted. Released as v0.1.0, with CI and real-database integration tests. Measured on a dev machine (Oct 2026): 10,000 same-transaction enqueues at 100% integrity, and tasks picked up about 2–3.7 seconds after a worker stopped renewing its lease.

GoMySQLTask Queue
GitHub repo ↗
Case Studies — Bugs I've Fixed
REDIS / GO-REDIS

False “pool exhausted” right after connection re-authentication

ProblemWith MaxActiveConns set to 1, a connection that has just finished re-authenticating is already idle — yet the very next command can still fail with “connection pool exhausted”. Running a reproduction script against the unfixed code, it hit about 51 times in 1,000 runs under -race.

Root CausegetConn first scans the idle connections with popIdle, but a connection mid-re-authentication is marked InUse and gets skipped. By the time the flow reaches the capacity check, that connection is back to Idle — yet the check only counts connections still flagged Unusable / InUse, so it misjudges the pool as full, goes off to dial, and hits the hard limit.

FixAt the capacity limit, before dialing or erroring out, re-check the idle list once: if a connection has become available, retry claiming it. One check only, no new waiting — the PoolTimeout budget and TryGet's non-blocking semantics stay untouched. The regression test was strengthened to 200 rapid credential rotations with concurrent PINGs, and it fails reliably on the unfixed code.

Merged · Nov 18, 2026 PR #4333 (closes #4332) ↗
GO-TASK / TASK

Optional remote includes error out offline when they aren't cached

ProblemMarking a remote include optional: true in a Taskfile is supposed to mean “skip it if it isn't there locally”. But with --offline and no cache present, the program didn't skip — it reported a cache-not-found error and exited with code 106.

Root Causeinclude.Optional was only checked in NewNode, when the node is constructed, while the offline cache lookup for a remote file happens later, in Node.Read(). The check and the failure sit in different places, so the optional flag never took effect on the offline path.

FixThe check moved earlier, into include() in reader.go: before adding a node to the graph, try reading the local cache first, and skip outright when the node is optional, offline, and remote with no cache. Cache errors from nested non-optional remote includes are kept from being swallowed by an optional parent, and unit tests now cover the direct and nested optional combinations.

Merged · Nov 6, 2026 PR #3081 (closes #3076) ↗
UBER / KRAKEN

Reviving four TLS client tests that had been skipped for six years

ProblemFour TLS client tests in utils/httputil had been skipped since 2019, sitting in the codebase year after year — nobody knew whether they would still pass.

Root CauseUnskipping them surfaced two unrelated failures. First, the generated test certificates carried only a CommonName and no SAN, which Go 1.15+'s x509 verification rejects outright. Second, a 2022 change had made HTTP fallback opt-in via EnableHTTPFallback, and the skipped tests had never caught up.

FixAdded DNSNames to the test certificate template, turned on EnableHTTPFallback() explicitly in the fallback test, and rebound the test server to 127.0.0.1:0 instead of a wildcard address. Test-only changes, verified locally with repeated -count=20 -race runs.

Merged · Oct 27, 2026 PR #729 (closes #230) ↗
News & Activity
  • 2026-11-18PR merged into redis/go-redis: fixed false “pool exhausted” errors right after connection re-authentication.
  • 2026-11-16PR opened to pingcap/tidb: a fix for field-type cloning in memtables.
  • 2026-11-10Released orangecode, my open-source Agent Harness.
  • 2026-11-06PR merged into go-task/task: offline mode now skips uncached optional remote includes.
  • 2026-10-27PR merged into uber/kraken: re-enabled four TLS client tests that had been skipped since 2019.
Principles — How I Work
01Reproduce first, then fix.

Before opening a PR, reproduce the issue locally, exactly as it happens. If it can't be reproduced, don't rush to a conclusion.

02Keep it verifiable.

In résumés and PR descriptions, write only what can be verified: every number with a source, every conclusion open to re-checking.

03Fix once, test forever.

Every fix ships with a regression test, so the same problem never gets a second chance.

Contact

Get in touch about Go, open source, or internship opportunities:

Email · tidehyc3234@163.com GitHub · @Tidehyc ↗