Q:

Have a mutable sequence or always delete and create a new immutable sequence?

I have an IndexedSeq that I will read some stuff from then update it and loop.
Which is more efficient:

Have one mutable IndexedSeq and update it and read from it
Every time I want to update, delete it and construct a new immutable IndexedSeq

So, Scala defaults to immutable (second method). Isn't it inefficient having to delete and allocate again and again for a million time every 3 seconds?

A:

Given how you posed the question, I strongly suspect that you already know the answer (for some cases).
However, which is more dangerous?

Have one mutable IndexedSeq accessed by all sorts of different methods
Make each method create a new internally-consistent IndexedSeq if that method needs to change it

The nice thing about immutability is that it's easy to reason about, not that it's fast.  That said, various tree structures can get you back into O(log n) territory for operations you might fear are O(n); sometimes even O(1) is possible by cleverly choosing the data structure.
In particular, Scala's Vector is the default IndexedSeq, and it has an updated method that only does O(log n) work, with a base on the logarithm of 32.  It's certainly nowhere near as fast as updating an array; depending on details it might even be 100x slower.  But most of the time you don't actually need something 100x faster, you need something that isn't broken.
The trick is in knowing your requirements and using the appropriate language constructs in the appropriate places.

