Skip to content

Releases: danvk/effective-typescript

Second Edition

13 May 14:11
6a9a6b5
Compare
Choose a tag to compare

[Released] May 2024.

Highlights

  • There's substantially more book! 250 → 375 pages, 62 → 83 items
  • Code samples use Twoslash syntax to indicate the types of symbols. This better aligns with the TypeScript Playground.
  • There are many more references to relevant eslint / typescript-eslint rules throughout the book.
  • This repo now includes a Markdown file for each item including "Things to Remember" and a full list of code samples with TypeScript playground links.

Detailed Diff

  • 📖 New Chapters:
    • Chapter 6: Generics and Type-Level Programming
    • Chapter 7: TypeScript Recipes
  • ➕ New Items
    • Item 28: Use Classes and Currying to Create New Inference Sites
    • Item 32: Avoid Including null or undefined in Type Aliases
    • Item 36: Use a Distinct Type for Special Values
    • Item 37: Limit the Use of Optional Properties
    • Item 38: Avoid Repeated Parameters of the Same Type
    • Item 39: Prefer Unifying Types to Modeling Differences
    • Item 48: Avoid Soundness Traps
    • Item 50: Think of Generics as Functions Between Types
    • Item 51: Avoid Unnecessary Type Parameters
    • Item 53: Know how to Control the Distribution of Unions over Conditional Types
    • Item 54: Use Template Literal Types to Model DSLs and Relationships Between Strings
    • Item 56: Pay Attention to how Types Display
    • Item 57: Prefer Tail-Recursive Generic Types
    • Item 58: Consider Codegen As an Alternative to Complex Types
    • Item 59: Use Never Types to Perform Exhaustiveness Checking
    • Item 62: Use Rest Parameters and Tuple Types to Model Variadic Functions
    • Item 63: Use Optional Never Properties to Model Exclusive Or
    • Item 71: Use Module Augmentation to Improve Types
    • Item 74: Know How to Reconstruct Types at Runtime
    • Item 76: Create an Accurate Model of Your Environment
    • Item 77: Understand the Relationship Between Type Checking and Unit Testing
    • Item 78: Pay Attention to Compiler Performance
  • ➖ Dropped Items
    • Item 56: Don't Rely on Private to Hide Information
  • 🚧 Items with Major Changes
    • Item 13: Know the Differences Between type and interface
      • Changed the conclusion to favor interface.
      • Added example of type inlining, removed functions w/ properties.
    • Item 14: Use readonly to Avoid Errors Associated with Mutation (was Item 17)
      • Added more discussion of readonly property modifier as a lead-in to ReadonlyArray
    • Item 15: Use Type Operations and Generic Types to Avoid Repeating Yourself
      • Was Item 14: Use Type Operations and Generics to Avoid Repeating Yourself
      • Removed most material on generics.
      • Reworked many examples.
      • Added deeper discussion of mapped types including homomorphic mapped types and "as" clause.
    • Item 16: Prefer More Precise Alternatives to Index Signatures
      • Was Item 15: Use Index Signatures for Dynamic Data
      • Reframed as "Prefer more Precise Alternatives to Index Signatures".
      • Expanded discussion of ES6 Map.
      • Added template literal type example.
    • Item 17: Avoid Numeric Index Signatures
      • Was Item 16: Prefer Arrays, Tuples, and ArrayLike to number Index Signatures
      • Reframed as "Avoid Numeric Index Signatures"
      • Updated examples
      • Added discussion of iterables/generators
    • Item 20: Understand How a Variable Gets Its Type
      • Was Item 21: Understand Type Widening
      • Used more official terminology.
      • Added tuple() helper.
      • Added discussion of satisfies operator.
    • Item 42: Avoid Types Based on Anecdotal Data
      • Was Item 35: Generate Types from APIs and Specs, Not Data
      • Focused more on "avoid types based on anecdotal data."
      • Replaced GraphQL example w/ OpenAPI.
    • Item 45: Hide Unsafe Type Assertions in Well-Typed Functions (was Item 40)
      • Ditched cacheLast (memoize) example in favor of fetching JSON
    • Item 47: Prefer Type-Safe Approaches to Monkey Patching (was Item 43)
      • Focused on modeling global userFromPageLoad example
    • Item 55: Write Tests for Your Types
      • Was Item 52: Be Aware of the Pitfalls of Testing Types
      • Nearly complete rewrite.
      • Added discussion of expect-type, the Type Challenges approach, and eslint-plugin-expect-type.
    • Item 70: Mirror Types to Sever Dependencies (was Item 51)
      • The conclusion stays the same but the whole argument has changed.
    • Item 72: Prefer ECMAScript Features to TypeScript Features (was Item 53)
      • Updated discussion of decorators
      • Added TypeScript private visibility modifier, which was formerly its own item: "Item 56: Don't Rely on Private to Hide Information."
    • Item 73: Use Source Maps to Debug TypeScript (was Item 57)
      • Added discussion of debugging Node.js code.
    • Item 79: Write Modern JavaScript (was Item 58)
      • Focused on imports and classes
      • Moved most of the old sections into a bulleted list
  • ✏️ Items with Minor Changes
    • Item 1: Understand the Relationship Between TypeScript and JavaScript
    • Item 2: Know Which TypeScript Options You're Using
    • Item 3: Understand That Code Generation Is Independent of Types
    • Item 4: Get Comfortable with Structural Typing
    • Item 5: Limit Use of the any Type
    • Item 6: Use Your Editor to Interrogate and Explore the Type System
    • Item 7: Think of Types as Sets of Values
    • Item 8: Know How to Tell Whether a Symbol Is in the Type Space or Value Space
    • Item 9: Prefer Type Annotations to Type Assertions (was Item 9: Prefer Type Declarations to Type Assertions)
    • Item 10: Avoid Object Wrapper Types (String, Number, Boolean, Symbol, BigInt)
    • Item 11: Distinguish Excess Property Checking from Type Checking (was Item 11: Recognize the Limits of Excess Property Checking)
    • Item 12: Apply Types to Entire Function Expressions When Possible
    • Item 18: Avoid Cluttering Your Code with Inferable Types (was Item 19)
    • Item 19: Use Different Variables for Different Types (was Item 20)
    • Item 21: Create Objects All at Once (was Item 23)
    • Item 22: Understand Type Narrowing
    • Item 23: Be Consistent in Your Use of Aliases (was Item 24)
    • Item 24: Understand How Context Is Used in Type Inference (was Item 26)
    • Item 25: Understand Evolving Types (was Item 41: Understand Evolving any)
    • Item 26: Use Functional Constructs and Libraries to Help Types Flow (was Item 27)
    • Item 27: Use async Functions Instead of Callbacks to Improve Type Flow (was Item 25: Use async Functions Instead of Callbacks for Asynchronous Code)
    • Item 29: Prefer Types That Always Represent Valid States (was Item 28)
    • Item 30: Be Liberal in What You Accept and Strict in What You Produce (was Item 29)
    • Item 31: Don’t Repeat Type Information in Documentation (was Item 30)
    • Item 33: Push Null Values to the Perimeter of Your Types (was Item 31)
    • Item 34: Prefer Unions of Interfaces to Interfaces with Unions (was Item 32: Prefer Unions of Interfaces to Interfaces of Unions)
    • Item 35: Prefer More Precise Alternatives to String Types (was Item 33)
    • Item 40: Prefer Imprecise Types to Inaccurate Types (was Item 34: Prefer Incomplete Types to Inaccurate Types)
    • Item 41: Name Types Using the Language of Your Problem Domain (was Item 36)
    • Item 43: Use the Narrowe...
Read more

First Edition

13 May 14:09
71e7bcd
Compare
Choose a tag to compare

Released October 2019