Ergonomic, hermetic, user-friendly software build system for Python, Go, Java, Kotlin, Protobuf, Scala, Shell. Pants lets you fearlessly scale up your codebase!

Pants

So I've explained how the goal graph works

I might be tempted to call foo.jar a "product" but based on this conversation, I will forebear from doing so

Let me explain the how it relates to the target graph

Now that you've scheduled your goals, say with the example above, pretend we're running `./pants test some/target:foo`

First, pants looks at the target spec you passed in and constructs the target graph

This is simply the transitive closure (where target `dependencies` are the edges) of the targets you pass it on the RHS of a pants invocation

Based on the scheduling above, `resolve` runs, and pretend its only task is `IvyResolve`.  So `IvyResolve` runs and it sees that the target graph is `some/target:foo` and its dependencies--for now let's pretend it has none

The `compile_classpath` product is effectively a mapping from individual targets to the actual concrete third party jars on disk that Ivy claims that target represents

Ivy populates this product as such.  So if `some/target:foo` is a `JarLibrary` target that defined some `jar(...)`, it will have an entry in this particular product map

Compile is going to consult that input product in order to construct classpaths for individual targets that it's compiling

To be specific, `compile_classpath` is a map from `some/target:foo` to an array of third-party jars on disk

Slightly more complicated, but yes that is the gist

Basically there's some extra metadata in there too

`compile`, specifically `ZincCompile` then populates a very similar product named `runtime_classpath` with an equivalent mapping of loose classfiles or compiled jars, target to classpath again

The "product" of IvyResolve is a `compile_classpath`. What's the "product" of JarLibrary? the actual built jar? a map from `foo` to the built jar? (and also the jar itself?)

The maven equivalent is like `&lt;dependency&gt; ...` in a pom

Sorry I should have been even more concrete

So you can see how each task only operates on the subset of target types it cares about

That's sort of the last piece of the puzzle

Every task operates on the entire target graph--but every task first filters the graph to only target types that it cares about

So those product maps from target to &lt;whatever&gt; are really only mapping the _relevant_ target types

What is the Pants name for a file generated by the build?