Should I use TypeScript or JavaScript for a new project?

TypeScript, without exception. The compilation overhead is negligible — modern build tools (Vite, esbuild, Next.js) strip types at zero runtime cost. The benefits — IDE intelligence, compile-time error catching, safe refactoring — pay dividends from the first week and compound as the codebase grows. There is no technical argument for starting a new production project in plain JavaScript.

What does TypeScript strict mode enforce?

Enabling `"strict": true` in tsconfig activates several flags: `noImplicitAny` (all types must be explicit), `strictNullChecks` (null and undefined are not assignable to typed variables without explicit handling), `strictFunctionTypes` (function parameter types are contravariant) and others. We enforce strict mode on every project and do not allow `any` except in type-safe utility code where the type is constrained by surrounding checks.

Do I still need runtime validation if I use TypeScript?

Yes. TypeScript types exist only at compile time — they are erased in the compiled JavaScript. Any data crossing a system boundary (API responses, form inputs, database reads, webhook payloads) is untyped at runtime. We use Zod for runtime schema validation at all API entry points, parsing external data into typed structures before it enters the application. TypeScript and Zod together give both compile-time and runtime safety.

How do you onboard new developers to a TypeScript codebase?

TypeScript actually makes onboarding faster, not slower. Types serve as machine-checked documentation — a developer can see exactly what a function expects and returns without reading the implementation. IDE autocomplete guides them through unfamiliar code paths. Type errors catch mistakes before they reach review. The main onboarding task is explaining strict mode constraints — once understood, developers report higher confidence making changes to unfamiliar code.

Web

TypeScript

Type-safe JavaScript — non-negotiable on every Ascii-Core project.

Book a Discovery Call TypeScript website

TypeScript is a typed superset of JavaScript that compiles to plain JavaScript. Static types catch entire categories of runtime errors at build time, enable IDE intelligence and make large codebases navigable by new team members. We enforce strict TypeScript on every project — no `any`, no implicit types, no exceptions.

Why we chose it

Why Ascii-Core uses TypeScript

1
Catches type errors at compile time — eliminates a class of runtime bugs before they reach production
2
IDE autocomplete and inline documentation — speeds development and reduces documentation burden
3
Enables safe refactoring at scale — rename a property and every consumer is flagged immediately
4
Strict mode enforced on every project — `noImplicitAny`, `strictNullChecks`, `strictFunctionTypes`

Ideal use cases

When to use TypeScript

Every JavaScript/TypeScript project without exception
Teams that will evolve a codebase over multiple years
Projects with complex data models where type safety prevents schema drift
Monorepos where type sharing between packages eliminates contract mismatches

Trade-offs

Honest limitations

We believe in accurate trade-offs. These are the cases where a different tool may be the better choice.

Adds compilation step and build configuration complexity
Type gymnastics for complex generic types can reduce readability for less experienced developers
Not a substitute for runtime validation at API boundaries — still need Zod or equivalent

Services