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

Pants

<@U054MQUPL>: so, slots aren’t worth it. because hashing the classes contents is more expensive than tuple hashing. But reading about them has made me realize that we could save more space by adding `__slots__ = ()` to the appropriate class declarations

namedtuple sets it to (), but the quirk of __slots__ is that subclasses without a slots declaration get the dict back

<@U066LC126> : the datatype thing is turning into a bit of a boondoggle, imo. would be good to get back on the type verification.

at least in my profiling, nothing related to the data shows up

and i'm planning to make it mostly/entirely disappear soon.

```#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct SelectLiteral {
  subject: Key,
  variants: Variants,
  selector: selectors::SelectLiteral,
}

impl Step for SelectLiteral {
  fn step(&amp;self, _: StepContext) -&gt; State {
    State::Complete(Complete::Return(self.selector.subject.clone()))
  }
}```

<@U054MQUPL>: I want to clarify something about <https://github.com/pantsbuild/pants/issues/3792>. So currently we create LegacyBuildGraph prefork. and after your change, we will have product graph prefork and use that to create LegacyBuildGraph post fork. does this sound correct?

we’re running into issues where old copies of `LegacyBuildGraph` are lingering in memory in the daemon

so every run adds N new target types to memory run over run

so we defer that until post-fork to not pollute the daemon’s memory space

theres a bit more optimization that can be done around the warming and LBG construction efficiency, fwiw

this just gets us to a cleaner memory profile for now, then we can probably kill LBG altogether by inverting that into a factory that creates targets from an index and injects them into a real `BuildGraph`

so now each daemon process has its own version of LegacyBuildGraph?

they always have, this just prevents the daemon’s memory space from hanging onto old ones from prior runs - and then forking w/ that

by deferring the construction into an entirely separate process space

every run daemon will create a process which will has daemon’s LGB