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

Pants

Dragging the entire scala runtime into this seems like a lot of bloat

<@U051221NF>: runtime as in cpu/memory usage?

but yes, also all the cpu/memory usage that incurs

just classloading the scala libs is slow and bloat-y

Using scala on the client seems like a pretty risky bet

how’s `list-owners` used? ```[tw-mbp-yic pants (master)]$ ./pants list-owners examples/src/java/org/pantsbuild/example/hello/greet/Greeting.java 

Exception message: /Users/yic/workspace/pants/examples/src/java/org/pantsbuild/example/hello/greet/Greeting.java does not contain any BUILD files.
  when translating spec examples/src/java/org/pantsbuild/example/hello/greet/Greeting.java```

:tada: Your ivy changes are exciting Nick!

Scopes look interesting too. We’ve had some requests for things like that internally off and on.

<@U053HHEDG>, <@U053H6LQS> : so one thing that i think deserves serious thought

"should dependency scopes be a property of the dependency or the dependent?"

maven puts them on the dependent. but i think that's primarily because in maven you don't have 1st class 3rdparty entries

Putting them on the dependency seemed to make more sense

<@U053HHEDG>: you have them on the dependent

putting them on the dependency would mean marking "hadoop-core" a "compiletime" dep, once

rather than having all dependents of hadoop-core marking it compiletime

rather than the vertices (the actual targets)

since we don't have first class edges, i think it's safe to say they are currently declared "on" the dependent

It’s valid for some targets to have a scoped dependency on a target, while other targets may depend on them normally

<@U053HHEDG>: could you flesh out some more usecases for that? i'm not sure how common it is in practice

In the case of a diamond, this results in the most-lenient scopes winning

but it also seems like it could be easily solved with a layer of indirection

Say T depends on A and B. B has a provided dependency on Q, but A depends directly on Q

Layers of indirection get sticky because of things like intransitive dependencies