Page plan · 14 pages

Written for: software developers and engineering leads

1. 1

   Tern: one fast command-line tool for project dependencies

   • Meet Tern, a fictional command-line tool built to manage project dependencies quickly.
   • One binary replaces a patchwork of separate dependency utilities.
   • This talk is for developers and engineering leads who maintain real projects.
   • We will cover the problem, the workflow, a demo and how to try it.
2. 2

   The tension: too many separate tools

   • Most projects juggle several tools for installs, scripts and runtime versions.
   • Each tool brings its own config file, its own commands and its own quirks.
   • Onboarding slows down when a newcomer must learn and install every one of them.
   • Drift between machines and CI grows as the number of tools grows.
3. 3

   Where Tern fits beside package managers

   • Tern is meant to sit beside your existing package managers, not erase them.
   • It focuses on the workflow around dependencies: setup, scripts and versions.
   • Teams can adopt it on one project without rewriting everything else.
   • The goal is fewer moving parts, not a new ecosystem to maintain.
4. 4

   From init to lockfile in one tool

   • Tern init creates a project with sensible defaults in one command.
   • Adding a dependency updates the manifest and resolves versions in the same step.
   • The lockfile records exact versions so every machine installs the same tree.
   • Init, add and lock all happen in one tool, with one config.
5. 5

   Live demo: setting up a fresh project

   • We start from an empty folder and run the init command.
   • Next we add a dependency and watch the lockfile appear.
   • Then we run the install from a clean state to show the speed.
   • Anyone on the team can repeat these same steps on their own machine.
6. 6

   Scripts and one-off tools

   • Project scripts live in the same Tern config as your dependencies.
   • Run a script by name with one command, with no extra task runner needed.
   • One-off tools can run on demand without being installed globally.
   • This keeps global machine state clean and results repeatable.
7. 7

   Managing toolchain versions

   • Tern can pin the toolchain version a project expects, such as the language runtime.
   • The pinned version lives in the repository, so it is shared with the whole team.
   • Switching between projects picks up the right version automatically.
   • CI can use the same pin, which reduces works-on-my-machine failures.
8. 8

   A setup script before and after Tern

   • Before: a setup script chains several tools and manual version checks.
   • The old script is long, fragile and needs updates whenever a tool changes.
   • After: the script shrinks to a few Tern commands reading one config.
   • Fewer lines means fewer places for new contributors to get stuck.
9. 9

   A proof point from a monorepo migration

   • This page describes a monorepo migration as the proof point for Tern.
   • Monorepos magnify dependency pain because many packages share one install.
   • Any timing or size figures shown here should be measured on your own repo.
   • Treat the example as a pattern to test, not a guarantee of results.
10. 10

    What Tern covers, from installs to toolchains

    • Coverage starts with dependency installs and the lockfile.
    • It extends to scripts, one-off tool runs and toolchain version pinning.
    • Each area uses the same config and the same command style.
    • You can adopt the pieces one at a time as your needs grow.
11. 11

    Shipped today versus still in preview

    • Shipped features are ready to use today in real projects.
    • Preview features are still changing, so commands and behavior may shift.
    • Avoid depending on preview features for critical production pipelines.
    • Feedback on preview features directly shapes what ships next.
12. 12

    Platforms, install methods and licence

    • Check which operating systems Tern supports before rolling it out to a team.
    • Install methods should cover a quick script and a standard package route.
    • The licence terms matter for company use, so read them before adopting.
    • Pin the installed Tern version in CI for repeatable builds.
13. 13

    Where the claims in this deck come from

    • Tern is a fictional tool, so this deck's claims come from the launch brief.
    • General statements about dependency tooling reflect widely known practice.
    • Any numbers marked illustrative are examples, not measurements.
    • Verify performance on your own projects before making decisions.
14. 14

    Try Tern on one project this week

    • Pick one small project and try Tern this week.
    • Run init, add a dependency and compare the setup against your current flow.
    • Note what is faster, what is missing and what surprises you.
    • Share your findings with your team and decide whether to expand.