ModuleXC — Systems Developer

who I am

About me

I'm ModuleXC — systems developer focused on architecture and how code holds up under pressure. Started in 2019 with no mentor, no English — just broken code and curiosity until things clicked.

My main language is Lua / Luau. I know it well enough to dissect other people's codebases, refactor them, and build things others avoid because "it's too complex". Security systems, network layers, modular frameworks.

Outside of that I'm learning general backend and systems programming — Node, Python, C#, C++. Building toward running my own dev operation. Taking it slow, doing it right.

OOPmetatablesnetwork layers anti-cheatmodular archshrimp · INTP

profile.lua

1-- developer profile

3name = "ModuleXC"

4focus = "Systems / Arch"

5since = 2019

7main = "Lua / Luau"

8learning = "Node, Python, C#"

9location = "Ukraine"

10shrimp = true

11-- sleep_schedule = nil

modulexcONLINE

doctrine

How I build

Don't trust the client. Make it pretty for the client.

Server validates. Client gets the smooth toast and the spinning loader. Both win.

Two or three remotes are enough. Stop spawning new ones.

Every project has the same payload shapes — route them through one entry. Less surface, less drift.

Modules are friends, not strangers.

Coupling is fine when it's intentional. Pretending modules are isolated when they aren't is worse than admitting the dependency.

OOP in Luau is ugly. Use it anyway. Scale demands it.

Metatables look weird, but a project past 5k lines without classes turns into a swamp. Pick the swamp you can drain.

One RemoteFunction router. Everything flows through it.

Server-side dispatcher with rate limits and validation per route. Adding a new feature shouldn't require new infrastructure.

Use the right tool. Heartbeat:Wait() beats task.wait(0.1).

"Roughly waits a tenth of a second" is not a behaviour. Frame-locked is.

If a module breaks 300 lines, it's doing two things.

Length is a smell, not a rule. But the smell is usually right.

post-mortems

Bugs I caught

INCIDENT-001 RESOLVED LEGACY · YEARS-OLD CODE

SYMPTOM

TDS enemies jittered visibly every frame. Looked like the game was lagging, but FPS was fine.

DIAGNOSIS

Position update loop used task.wait(0.1). The actual interval drifted with frame load — sometimes 80ms, sometimes 130ms. Interpolation between waypoints assumed a constant tick. It was not constant. The lie was visible.

FIX

Killed all task.wait in the movement hot path. Rebound to RunService.Heartbeat. Used the dt argument to advance progress, instead of guessing.

CODE

BEFORE — drift accumulates, frames lie // reconstruction from memory

while enemy.Alive do
    task.wait(0.1)  -- "roughly" 100ms — never actually 100ms
    progress += 0.1 * enemy.Speed
    enemy.Model:SetPrimaryPartCFrame(path:GetCFrameAt(progress))
end

AFTER — frame-locked, dt-driven // reconstruction from memory

local conn
conn = RunService.Heartbeat:Connect(function(dt)
    if not enemy.Alive then conn:Disconnect() return end
    progress += dt * enemy.Speed
    enemy.Model:SetPrimaryPartCFrame(path:GetCFrameAt(progress))
end)

Frame-locked beats time-locked. Always.

INCIDENT-002 RESOLVED

SYMPTOM

Towers fired in wrong directions. Sometimes hits registered on players standing nowhere near the line of fire.

DIAGNOSIS

Tower rotation was server-authoritative. By the time the client rendered the model, the server's "current angle" was already 1–2 frames stale. Visual barrel pointed one way, hit-detection used another. Compounded by a half-finished Enemy AI that didn't gate friendly-fire — damage applied to whoever was closest to the bullet, including the player who placed the tower.

FIX

Split the system. Server now owns logic — when to fire, what to hit, who takes damage. Client owns show — rotation, animation, recoil. Wrote two new modules: AnimationUtil and Animator per tower type, listening for server signals like fire and idle. Friendly-fire gate moved server-side.

Server owns the truth. Client owns the show.

INCIDENT-003 RESOLVED

SYMPTOM

Damage buffs worked numerically — towers dealt boosted DPS — but the firing animation still played at base speed. Bullets came out between idle frames with no shooting motion at all on faster cooldowns.

DIAGNOSIS

The buff was a free-floating variable on the side of the combat module. The Animator had no idea it existed. Cooldown dropped, animation length didn't.

FIX

Refactored the buff into a state table on the tower itself — every modifier now lives in one place. Animator reads from that state and scales playback speed proportionally: animationSpeed = baseDuration / currentCooldown. One source of truth, two consumers.

State scattered is state mocked. Centralize or suffer.