What Would a Cat Do? – 'Safe' Languages

There is strange new obsession with safety, as if the biggest problem in software isn't balooned overengineering but whether some function might return null in JavaScript app nobody will use in six months.

They hide behind so-called "safe" languages like TypeScript, Java, Rust — where compiler handholds them like a clueless intern who thinks CI/CD is an actual skill.

"Memory safety! Null safety! Type safety! Look, my language stops me from making mistakes!"

But what would a Cat do?

Cat trusts the skills it has, moves efficiently, and has concerns only with real threats, never imaginary ones.

Cat would write in C.

C doesn't ask pointless questions. It assumes you know what you're doing. If you don't, that's your problem.
C doesn't slow you down with endless safety checks that try to protect you from yourself. The cat does not baby itself.
C compiles straight to raw, unfiltered performance.
C doesn't lie. Unlike TypeScript, it doesn't pretend to "fix" JavaScript.

Cat knows that true safety is in mastery. If you understand memory, pointers, and execution, you don't need a language to save you.

Real safety is in knowing what your code does.

Cats don't file Jira tickets.
Cats don't use dependency managers for basic functionality.
Cats don't run a Kubernetes cluster just to serve a static website.

A cat writes the simplest, most direct solution possible, not:

type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

type APIResponse<T> = 
    | { success: true; data: T }
    | { success: false; error: string };

type InferRole<T> = 
    T extends { admin: true } ? "admin" 
    : T extends { moderator: true } ? "moderator" 
    : "user";

type User<T extends Record<string, unknown>> = T & {
    id: number;
    name: string;
    roles: InferRole<T>[];
    metadata?: DeepPartial<{
        lastLogin: Date;
        settings: {
            theme: "light" | "dark";
            notifications: boolean;
        };
    }>;
};

function fetchUser<T extends Record<string, unknown>>(id: number): Promise<APIResponse<User<T>>> {
    return new Promise((resolve) => setTimeout(() => resolve({
        success: true,
        data: {
            id,
            name: "John Doe",
            roles: ["user"],
            metadata: {
                lastLogin: new Date(),
                settings: { theme: "dark", notifications: true }
            }
        } as User<T>
    }), 1000));
}

Imagine this being everywhere in your codebase.

Cat in C...

struct User {
    int id;
    char name[50];
    int is_admin;
    struct {
        time_t last_login;
        int dark_mode;
        int notifications;
    } settings;
};

struct APIResponse {
    int success;
    union {
        struct User data;
        char error[256];
    };
};

What would a Cat do? – 'Safe' languages