Imperative vs Functional - understanding the von Neumann bottleneck

In Curser's course - Functional Programming in Scala - Martin Oderski talks about how imperative programming is constrained by the von Neumann bottleneck because it is heavily concerned with mutable state, and therefore also assignment and de-referencing.

Von Neumann's bottleneck is the read / write latency between the processor and memory.

I am struggling to understand 2 things and hope someone can help shed some light on it: -

• If we use immutable objects when writing a Scala program, then we still have an assignment where we initialize an immutable object with data when it is created, but not later re-assignment. When we want to unreference an immutable object then there is still a chance that it will no longer exist in the cache and will need to be fetched again from main memory -> latency.

  I am struggling to understand how using immutable data structures helps with von Neumann's bottleneck. Can anyone help me assess the cases where this happens?

• In his lecture, Martin Oderski states the following when talking about von Neumann's bottleneck: -

  Imperative programming conceptualizes programs word for word, becomes a scalability issue because we are dealing with structure data at too low a level. Functional programming languages (in general) tend to focus on the definition of the theories and methods of work with higher-level abstractions, such as collections
  
  , polynomials
  
  , documents
  
  , etc.

  I understand that using higher level abstractions can really help a developer evaluate the effectiveness of their development work, but how do abstractions help solve the von Neumann bottleneck?