TypeScript Communication & Stakeholder Relations 5 — Questions and Answers
Question 1: A manager asks why the TypeScript team spends time writing `.d.ts` declaration files for an internal SDK. What is the business justification?
- Declaration files replace the need for unit tests
- Declaration files let consumer teams get full IDE auto-complete and type safety without shipping source code (Correct answer)
- Declaration files are required for the TypeScript compiler to run
- Declaration files improve JavaScript runtime performance
Correct answer: Declaration files let consumer teams get full IDE auto-complete and type safety without shipping source code
Publishing `.d.ts` files alongside compiled JavaScript gives consumers IDE support and compile-time safety without exposing proprietary source code.
Question 2: A stakeholder asks how to communicate breaking changes when releasing a new major version of a TypeScript library. What is the recommended approach?
- Breaking changes do not need to be communicated if the version number is bumped
- Document breaking type changes in a CHANGELOG, use semantic versioning, and provide a migration guide explaining how to update consuming code (Correct answer)
- Only notify consumers if the JavaScript output changes, not the types
- Breaking changes should be avoided by never changing types
Correct answer: Document breaking type changes in a CHANGELOG, use semantic versioning, and provide a migration guide explaining how to update consuming code
Combining semantic versioning, a detailed CHANGELOG, and a migration guide gives consumers the context they need to update their code confidently.
Question 3: During code review, a reviewer asks why a function parameter is typed as `T extends Record<string, unknown>` instead of `object`. What should the author explain?
- The constraint is purely cosmetic with no functional difference
- The constraint ensures `T` is an object with string keys and unknown values, enabling safe key access while preserving the caller's specific type through generics (Correct answer)
- `object` is not a valid TypeScript type
- The `extends` keyword here creates a subclass at runtime
Correct answer: The constraint ensures `T` is an object with string keys and unknown values, enabling safe key access while preserving the caller's specific type through generics
Constraining a generic with `Record<string, unknown>` allows key access without losing the caller's specific type information, unlike using the opaque `object` type.
Question 4: A product owner wants to understand why the team is migrating from JavaScript's `class` private fields to TypeScript's `private` keyword for internal APIs. What is the communication gap to address?
- TypeScript `private` is stronger than JavaScript's `#` private fields
- TypeScript `private` is compile-time only and visible at runtime, while `#` provides true runtime encapsulation; teams should know which guarantee they need (Correct answer)
- Both `private` and `#` produce identical JavaScript output
- TypeScript `private` prevents the property from appearing in `JSON.stringify`
Correct answer: TypeScript `private` is compile-time only and visible at runtime, while `#` provides true runtime encapsulation; teams should know which guarantee they need
TypeScript's `private` keyword is erased at compile time and accessible at runtime via bracket notation, while JavaScript `#` fields are truly inaccessible outside the class.
Question 5: A frontend developer joins a fullstack TypeScript team and asks how to validate that runtime API responses match TypeScript types. What tool or pattern should be recommended?
- TypeScript automatically validates runtime data against declared types
- Use a runtime validation library like Zod or io-ts to parse and validate external data, inferring TypeScript types from the schema (Correct answer)
- Cast the response to the expected type with `as` to ensure compatibility
- Strict mode enables runtime type checking for API responses
Correct answer: Use a runtime validation library like Zod or io-ts to parse and validate external data, inferring TypeScript types from the schema
Libraries like Zod allow you to define a schema once, validate runtime data against it, and automatically infer the corresponding TypeScript type.
Question 6: A stakeholder notices that two teams use different TypeScript `tsconfig.json` settings and asks if this is a problem. How should you respond?
- Different tsconfig settings are always fine and have no impact on shared code
- Inconsistent settings like different `target` or `strict` options can cause incompatible output or missed errors when sharing code between teams, and a shared base config should be considered (Correct answer)
- tsconfig settings only affect code formatting, not correctness
- Each team should always have a completely unique tsconfig with no sharing
Correct answer: Inconsistent settings like different `target` or `strict` options can cause incompatible output or missed errors when sharing code between teams, and a shared base config should be considered
A shared base `tsconfig` ensures consistent strictness and output targets, preventing subtle bugs when code is shared across team boundaries.
Question 7: A technical writer asks you to explain TypeScript's `satisfies` operator (introduced in TS 4.9) for inclusion in developer documentation. What is the key point?
- `satisfies` is a runtime assertion that throws if the type does not match
- `satisfies` validates that a value matches a type at compile time while preserving the value's most specific inferred type for subsequent use (Correct answer)
- `satisfies` replaces the `as` type assertion and is always safer
- `satisfies` is only available in TypeScript's strict mode
Correct answer: `satisfies` validates that a value matches a type at compile time while preserving the value's most specific inferred type for subsequent use
Unlike `as`, `satisfies` checks type compatibility without widening the value's type, so you get both validation and the benefit of the narrower inferred type downstream.
TypeScript Communication & Stakeholder Relations 5
A manager asks why the TypeScript team spends time writing `.d.ts` declaration files for an internal SDK.
What is the business justification?