How to Hire a Frontend Developer (TypeScript)

• aIgnore type errors and only add types to new modules
• bIncrementally add TypeScript using @ts-check and JSDoc annotationsCorrect
• cReplace all JavaScript files with .ts files without additional changes
• dRewrite the entire codebase in TypeScript immediately

Explanation: Incremental adoption allows teams to gradually introduce TypeScript into a legacy codebase, reducing risk and facilitating smoother integration. Using @ts-check at the top of JS files provides immediate type checking based on JSDoc annotations.

Why it matters: Tests practical migration strategy for large production applications without causing build failures.

• aUse the library with the 'any' type everywhere
• bRely solely on automated type generation tools without review
• cModify the library's source code to include types
• dCreate a custom .d.ts declaration file for the libraryCorrect

Explanation: Creating a custom declaration file provides explicit types, preserving type safety while allowing integration of untyped libraries. Candidate should describe using declare module 'untyped-pkg' { ... } in a custom types/ directory.

Why it matters: Verifies ability to create custom ambient declaration files for untyped third-party libraries.

• aRely solely on the typeof operator
• bImplement a user-defined type guard to differentiate typesCorrect
• cUse type assertions to cast the variable to the expected type
• dUse instanceof to check for array type

Explanation: A user-defined type guard allows for precise runtime checks between complex types, ensuring that each branch of logic handles the correct type. Candidate should note that Array.isArray() can serve as a built-in type guard, but user-defined type guards with type predicates (x is number[]) provide explicit safety.

Why it matters: Assesses runtime type-narrowing precision and implementation of user-defined type guards.

• aAvoid using generics and utilize the any type instead
• bOmit type annotations entirely to let inference handle everything
• cRequire explicit type annotations for every generic parameter
• dDefine default types for generic parametersCorrect

Explanation: Providing default types for generics simplifies component usage by reducing the need for explicit type parameters while still maintaining strong type safety. Candidate should demonstrate generic default syntax: <T = DefaultType>.

Why it matters: Tests proficiency with generic syntax and ergonomic API design in reusable components.

• aDisable source maps during compilation
• bTurn off strict type checking
• cEnable incremental compilation and use skipLibCheckCorrect
• dCompile with the target set to ES3

Explanation: Enabling incremental compilation and skipLibCheck helps reduce build times by avoiding unnecessary re-checking of already verified libraries. Candidate should explain that skipLibCheck skips checking all .d.ts files, saving significant CI execution time.

Why it matters: Evaluates knowledge of compiler flags that directly speed up continuous integration build times.

• aRely solely on JSDoc annotations and avoid full TypeScript migration
• bRewrite the entire application in TypeScript at once
• cEnable strict mode for the entire codebase immediately
• dRefactor modules incrementally while selectively applying @ts-ignore for unavoidable mismatchesCorrect

Explanation: This incremental approach allows teams to gradually introduce strict type checking, reducing risks and ensuring stability during migration. Candidate should also discuss replacing temporary @ts-ignore comments with @ts-expect-error as types are refined.

Why it matters: Evaluates enterprise migration strategy balancing strict typing enforcement with operational business continuity.

• aGeneric constraints using keyof and mapped typesCorrect
• bUsing intersection types to merge multiple type definitions
• cUsing the any type with runtime validations
• dCreating a union type of all possible object shapes

Explanation: Utilizing generic constraints with keyof and mapped types allows for precise type inference and ensures that only valid object keys are processed, maintaining type safety. Candidate should illustrate mapped types syntax: <T, K extends keyof T> and { [P in K]: T[P] }.

Why it matters: Checks ability to design generic object transformations using mapped types and keyof constraints.

• aUse higher-order components without integrating lazy loading
• bUtilize React.lazy and Suspense with properly typed dynamic importsCorrect
• cImplement custom dynamic import functions that bypass type checking
• dAvoid lazy loading entirely to keep the type system simple

Explanation: React.lazy and Suspense provide a built-in solution for lazy loading components, and when combined with proper TypeScript typing, they maintain type safety while optimizing performance. Candidate should explain that React.lazy expects a dynamic import returning a default export of a React component.

Why it matters: Tests integration of modern frontend code-splitting techniques with TypeScript type preservation.

• aDisable strict type checking to speed up the compilation process
• bEnable incremental builds and leverage project referencesCorrect
• cIncrease hardware resources without changing TypeScript configuration
• dSplit the monorepo into multiple unrelated repositories

Explanation: Incremental builds combined with project references reduce redundant type-checking across projects, effectively speeding up build times while preserving type safety. Candidate should mention composite projects and tsc -b.

Why it matters: Assesses high-scale build optimization in enterprise TypeScript monorepos.

• aApply immutable data principles with deep readonly types and pure functionsCorrect
• bRemove type checking in production builds to reduce overhead
• cRely on runtime optimizations without adjusting the TypeScript type system
• dUse dynamic types to allow for on-the-fly optimization

Explanation: Using immutable data structures and pure functions not only improves runtime performance by reducing side effects but also leverages TypeScript's type system to catch errors at compile time. Candidate should explain that compile-time readonly types carry zero runtime overhead.

Why it matters: Evaluates architectural synergy between type-level immutability and runtime performance optimization.