p9r
p9r

p9r.dev

code is the spray can. the web is the wall.

About

The Developer's Wall

Every developer leaves a mark. Not in spray paint on concrete, but in code committed to repositories, in architectures that outlive their creators, in elegant solutions that others build upon. p9r.dev is that mark — a personal tag on the infinite wall of the web.

The approach is methodical. Clean code. Precise implementation. But beneath the professionalism lives the raw energy of someone who writes code because they have to — because the ideas demand expression, because the problems refuse to stay unsolved.

philosophy.rs 
struct Developer {
    craft: Precision,
    drive: Relentless,
    medium: TheWeb,
}

impl Developer {
    fn create(&self) -> Impact {
        loop {
            let idea = self.observe();
            let solution = self.craft(idea);
            solution.ship();
        }
    }
}
Stack

Tools of the Trade

The craftsperson is defined by their tools — not by the tools themselves, but by the mastery with which they wield them. Every framework chosen is deliberate. Every language serves a purpose. The stack is lean, tested, and battle-hardened.

From systems-level Rust to expressive TypeScript, from container orchestration to edge deployment — the full spectrum of modern development, applied with intention.

Rust TypeScript Go WebAssembly Kubernetes Edge Functions
deploy.ts 
async function deploy(
    config: DeployConfig
): Promise<Deployment> {
    const artifact = await build({
        target: config.target,
        optimize: true,
        edge: config.regions,
    });

    const result = await distribute(
        artifact,
        config.regions
    );

    return {
        id: result.id,
        status: "live",
        latency: result.p99,
    };
}
Process

Method to the Mark

Street art appears spontaneous. The best of it is anything but. Behind every mural is planning — studying the wall, mixing colors, timing the execution. Software development shares this paradox: the output should feel effortless, but the process is rigorous.

Architecture first. Type safety always. Tests before deploy. Documentation as a first-class citizen. The discipline that makes the creative freedom possible.

pipeline.go 
func Pipeline(ctx context.Context) error {
    stages := []Stage{
        Lint(),
        TypeCheck(),
        UnitTest(),
        IntegrationTest(),
        SecurityScan(),
        Build(),
        Deploy(),
    }

    for _, stage := range stages {
        if err := stage.Run(ctx); err != nil {
            return fmt.Errorf(
                "stage %s: %w",
                stage.Name, err,
            )
        }
    }
    return nil
}