Skip to content
academia.sh
tr
Log in

Course Intermediate

Modules, Tooling and the Ecosystem

By the end of this course

Start course

01

Module Systems

The move from global scope pollution to module scope, the two module systems' binding and loading models, interoperability, and dynamic import.

  1. 01 The Need for Modules The name-collision problem born from sharing the global scope, the namespace pattern built with closures, and module scope's answer to that problem.
  2. 02 ES Modules Named and default export, import's live-binding behavior, binding coming before evaluation, and the opportunity static structure gives to tree shaking.
  3. 03 CommonJS The call-based loading model, the module wrapper and cache, the difference between a value copy and a live binding, the two systems' behavior on circular dependencies, and interoperability.
  4. 04 Dynamic Imports The promise-returning import expression, conditional loading with a computed specifier, the module registry's single-evaluation guarantee, and the cost balance of code splitting.

02

Package Management

The manifest and lock file, resolving bare specifiers, semantic versioning rules, conflicts in the dependency tree, workspaces, and managing dependency risk.

  1. 01 Package Registries and Dependencies The fields of the manifest file, resolving a bare specifier by walking the directory tree, encapsulation through the exports map, dependency types, and what the lock file does.
  2. 02 Semantic Versioning The promise carried by the three parts of a version number, comparison and precedence rules, pre-release tags, the bounds of version ranges, and the definition of a breaking change.
  3. 03 Dependency Trees and Conflicts How non-intersecting version requests are resolved by nested installation, the identity and state problems produced by duplicate copies, flattening the tree, and dependencies that require singularity.
  4. 04 Workspaces Keeping multiple packages in a single repository, the workspace declaration, resolving local packages through links, topological build order, and versioning strategies.
  5. 05 Dependency Risk Measuring the transitive dependency mass, what code running at install time means, integrity verification, locking discipline, package selection criteria, and managing abandoned packages.

03

Build Tools

Producing output from the module graph, adapting the source to the target environment, tracing back from generated output to the source, rule-based analysis and formatting, and task automation.

  1. 01 The Bundler Concept The rationale for producing a single output from a module graph, the three steps of a working bundler, the shape of the output, and how tree shaking is limited by side effects.
  2. 02 Transpilation and Targeting The split between syntax downleveling and capability polyfilling, determining a target set, what transpilation cannot solve, and cases where the source language differs from the target language.
  3. 03 Source Maps Mapping from a generated position to a source position, the map file's fields, how the mapping string is encoded, hand-building a map, and the decision to publish it in production.
  4. 04 Static Analysis and Formatting The limit of parse-level checking, the rule set and severity levels, the discipline of suppressing a warning, keeping formatting separate from analysis, and resilience under repetition.
  5. 05 Task Automation Storing script definitions in the manifest file, what a script runner does, lifecycle hooks, the exit-code contract, and a reproducible command set.

Start typing to search.

↑↓ ↵ Esc navigate · open · close