Articles & Resources #

Learning TypeScript from documentation and tutorials is a good first step, but becoming proficient requires broader exposure — reading how engineers at large tech companies solve real problems, following ecosystem developments, and understanding the trade-offs behind every technical decision. This page curates the most useful resources, updated regularly — from official documentation, books, video courses, to technical blogs that consistently produce high-quality content.

Official Documentation #

Official documentation is the most accurate and always up-to-date source. Always make it your first reference before looking anywhere else.

TypeScript #

Database and Cache #

Runtime and Ecosystem #

Books #

Books provide a more systematic and deeper understanding than articles or videos. Here are the most recommended books for TypeScript and related topics.

TypeScript #

Programming TypeScript — Boris Cherny The most complete book on TypeScript, covering the type system in depth — from the basics to type-level programming. Suitable for developers who want to truly understand how the TypeScript type system works, not just use it.

Effective TypeScript — Dan Vanderkam 52 concrete ways to write better TypeScript. Each item discusses one common mistake or anti-pattern along with its solution, complete with an explanation of why that solution is better. The dense, straight-to-the-point format makes this a reference you’ll open again and again.

TypeScript Deep Dive — Basarat Ali Syed Available free online at gitbook.io/read/book/basarat/typescript — very detailed coverage, especially of compiler internals and type declarations.

System Design and Architecture #

Designing Data-Intensive Applications — Martin Kleppmann A must-read for anyone working with databases, caching, and distributed systems. Discusses the trade-offs behind various technical choices — when to use SQL vs NoSQL, how replication and partitioning work, consistency vs availability. Very relevant for understanding the context behind MongoDB, Redis, and Elasticsearch.

Database Internals — Alex Petrov Explains how databases work from the inside — B-trees, LSM-trees, storage engines, distributed consensus protocols. A heavy read, but it gives you a strong foundation for making better technical decisions.

Clean Architecture — Robert C. Martin Architecture principles that apply across languages and frameworks. Helps you understand how to separate concerns in complex TypeScript applications — where business logic ends and the infrastructure layer (database, cache) begins.

Courses and Videos #

TypeScript #

Total TypeScript — Matt Pocock (totaltypescript.com) A series of interactive workshops covering TypeScript from a practical perspective. Matt Pocock is known for his extremely clear explanations of complex topics like generics, conditional types, and template literal types. There’s already very valuable free content before considering the paid version.

TypeScript Full Course — Traversy Media (YouTube) A solid introduction for developers just getting started. Good as a starting point before moving to deeper sources.

Execute Program — Gary Bernhardt (executeprogram.com) A learning platform using spaced repetition — material is studied in short sessions and repeated periodically. Its TypeScript content is highly recommended because it forces you to actually understand the material, not just watch it.

Database and Distributed Systems #

CMU Database Group — YouTube Recorded database lectures from Carnegie Mellon University — available free on YouTube. The series covers storage engines, query optimizers, concurrency control, and data distribution with an academic depth rarely found elsewhere.

Redis University — university.redis.com Official courses from the Redis team, available free. Covers Redis basics, data structures, production use cases, and Redis Streams.

Blogs and Newsletters #

These blogs consistently produce high-quality technical content, written by practitioners working on large-scale systems.

General Technical #

The Pragmatic Engineer — blog.pragmaticengineer.com A newsletter and blog covering engineering at large tech companies. Topics include large-scale systems, database design, and engineering careers. One of the most recommended technical newsletters today.

High Scalability — highscalability.com A collection of articles on how big companies (Netflix, Twitter, Uber, etc.) build and scale their systems. Often mentions the trade-offs between various database and caching choices.

Martin Fowler’s Blog — martinfowler.com A classic blog covering design patterns, architecture, and software engineering practices. His articles on caching patterns and data management are very relevant.

TypeScript and JavaScript #

Matt Pocock’s Blog — mattpocock.com In-depth articles about TypeScript — especially complex types. His explanations always come with concrete, immediately applicable examples.

Josh Goldberg — joshuakgoldberg.com The typescript-eslint maintainer who writes about TypeScript tooling, linting, and best practices in large-scale TypeScript projects.

2ality — 2ality.com (Dr. Axel Rauschmayer) A very detailed blog about JavaScript and TypeScript — including deep explanations of new ES2023+ features. The articles are long but very comprehensive.

Database Specific #

MongoDB Blog — mongodb.com/blog Official articles from the MongoDB team about patterns, performance, and new features. The “Best Practices” section is very useful for production deployments.

Elastic Blog — elastic.co/blog Guides, use cases, and best practices straight from the team that builds Elasticsearch. Topics include relevance tuning, query performance, and cluster architecture.

Redis Blog — redis.com/blog Articles about Redis features, production use cases, and performance guides from the Redis team.

Tools and Utilities #

Development #

TypeScript Tooling:
  tsc          — the official TypeScript compiler
  ts-node      — run TypeScript directly without compiling
  tsx          — a faster ts-node alternative (uses esbuild)
  tsup         — a zero-config TypeScript bundler
  typescript-eslint — ESLint rules specifically for TypeScript

Testing:
  vitest       — a fast test runner with native TypeScript support
  jest         — the most common test runner, needs extra config for TS
  @faker-js/faker — generate dummy data for testing

Type Utilities:
  zod          — schema validation with automatic type inference
  type-fest    — a collection of useful utility types
  ts-pattern   — type-safe pattern matching for TypeScript

Database and ORM #

ORM / Query Builder:
  Prisma       — a TypeScript-first ORM with an explicit schema
  DrizzleORM   — a lightweight query builder with full type inference
  TypeORM      — a decorator-based ORM for TypeScript
  Kysely       — a fully type-safe SQL query builder

MongoDB:
  mongodb      — the official driver (covered in this series)
  mongoose     — a popular ODM with schema validation

Elasticsearch:
  @elastic/elasticsearch — the official client (covered in this series)

Cache:
  ioredis      — the Redis client for Node.js (covered in this series)
  memjs        — the Memcached client for Node.js (covered in this series)
  node-cache   — a simple in-process cache without external dependencies

Monitoring and Observability #

APM and Tracing:
  OpenTelemetry (@opentelemetry/sdk-node) — a vendor-neutral observability standard
  Sentry       — error tracking with good TypeScript support
  Datadog APM  — performance monitoring for Node.js

Logging:
  pino         — a very fast logger with structured JSON output
  winston      — a flexible logger with many transports
  bunyan       — a stream-based logger for Node.js

Quick References #

TypeScript Cheatsheet #

// The most frequently used utility types
Partial<T>         // all fields become optional
Required<T>        // all fields become required
Readonly<T>        // all fields become immutable
Pick<T, K>         // take a subset of fields from T
Omit<T, K>         // drop a subset of fields from T
Record<K, V>       // an object with keys K and values V
Exclude<T, U>      // remove U from the union T
Extract<T, U>      // keep only U from the union T
NonNullable<T>     // remove null and undefined from T
ReturnType<T>      // get the return type of function T
Parameters<T>      // get the parameter types of function T
Awaited<T>         // unwrap a Promise type

// Type Guards
function isString(val: unknown): val is string {
  return typeof val === "string";
}

// Conditional Types
type IsArray<T> = T extends any[] ? true : false;

// Template Literal Types
type EventName = `on${Capitalize<string>}`;

// Mapped Types
type Nullable<T> = { [K in keyof T]: T[K] | null };

// Infer
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

Frequently Used Redis Commands #

# String
SET key value EX 3600    # set with a 1-hour TTL
GET key
INCR key
MGET key1 key2 key3

# Hash
HSET key field value
HGET key field
HGETALL key
HINCRBY key field 1

# List
RPUSH key value          # add to the right
LPOP key                 # take from the left (FIFO)
LRANGE key 0 -1          # get all

# Set
SADD key member
SMEMBERS key
SISMEMBER key member

# Sorted Set
ZADD key score member
ZRANGE key 0 -1 WITHSCORES
ZREVRANGE key 0 9        # top 10

# Utility
TTL key                  # remaining time to live
EXPIRE key 3600          # set a TTL
DEL key
SCAN 0 MATCH "prefix:*" COUNT 100

Frequently Used MongoDB Query Operators #

// Comparison
{ field: { $eq: val } }      // equal to
{ field: { $ne: val } }      // not equal
{ field: { $gt: val } }      // greater than
{ field: { $gte: val } }     // greater than or equal
{ field: { $lt: val } }      // less than
{ field: { $lte: val } }     // less than or equal
{ field: { $in: [a, b] } }   // in the array
{ field: { $nin: [a, b] } }  // not in the array

// Logic
{ $and: [kondisi1, kondisi2] }
{ $or: [kondisi1, kondisi2] }
{ $not: { kondisi } }

// Array
{ field: { $elemMatch: { kondisi } } }
{ field: { $size: n } }
{ field: { $all: [a, b] } }

// Update
{ $set: { field: val } }
{ $unset: { field: "" } }
{ $inc: { field: n } }
{ $push: { field: val } }
{ $pull: { field: val } }
{ $addToSet: { field: val } }

Community #

Joining the community is the best way to learn from others and stay updated with ecosystem developments.

Forums and Discussion:
  TypeScript Discord    — discord.gg/typescript
                          The official TypeScript community with per-topic channels
  r/typescript          — reddit.com/r/typescript
                          Discussion, questions, and TypeScript project showcases
  Stack Overflow        — stackoverflow.com/questions/tagged/typescript
                          A reference for specific questions that have already been answered

GitHub Repositories:
  microsoft/TypeScript  — TypeScript's source code and issue tracker
  DefinitelyTyped       — github.com/DefinitelyTyped/DefinitelyTyped
                          The @types/* repository — contribute types for untyped libraries

Conferences:
  TypeScript Congress   — typescriptcongress.com
                          An annual conference dedicated to TypeScript
  NodeConf              — a Node.js conference with lots of TypeScript content

Summary #

• Official documentation is always the first reference — the TypeScript Handbook, MongoDB Driver docs, Elasticsearch client docs, and ioredis docs are the most accurate and up-to-date sources.
• Books for a strong foundation — Programming TypeScript for the type system, Designing Data-Intensive Applications for understanding database and caching trade-offs at the architecture level.
• Total TypeScript and Execute Program are the two most recommended interactive TypeScript learning sources today — both force you to actively practice, not just watch.
• Important tools for the TypeScript ecosystem — Zod for validation with type inference, Prisma or DrizzleORM for databases, Vitest for testing, and pino for structured logging.
• Follow technical blogs regularly — The Pragmatic Engineer, 2ality, and Matt Pocock’s blog are sources that consistently produce high-quality content about TypeScript and engineering in general.
• Join the TypeScript Discord to get quick answers from the community and follow discussions about TypeScript features being developed.

← Previous: Memcached   Next: Strings →