immutability

Experiencing some unexpected performance from Microsoft ImmutableList from NuGet package Microsoft.Bcl.Immutable version 1.0.34 and also 1.1.22-beta When removing items from the immutable list the performance is very slow. For an ImmutableList containing 20000 integer values (1...20000) if starting to remove from value 20000 to 1 it takes about 52 seconds to remove all items from the list. If I do the same with a generic List<T> where I create a copy of the list after each remove operation it takes about 500 ms. I was a bit surprised by these results since I thought the ImmutableList would be

Closed . This question needs to be more focused. It is not currently accepting answers. Learn more . Want to improve this question? Update the question so it focuses on one problem only by editing this post . Closed 5 years ago . I am learning the concept of immutability. I understand that immutable objects cannot change their values once the object is created. But I didn't understand the following uses of immutable objects. They are are automatically thread-safe and have no synchronization issues. How ? Proof ? do not need a copy constructor. How ? Any example ? do not need an implementation

I am just getting started with .NET ORMs, to the point where I haven't even decided between Entity Framework and NHibernate. But in both cases, I'm running into a problem in that they seem to want me to compromise the integrity of my domain model in various ways, especially on finer points of C# object design. This is one of several questions on the subject. I am very used to enforcing immutability on appropriate properties with a pattern that looks like this: public class Foo { private readonly string bar; public string Bar { return this.bar; } public Foo(string bar) { this.bar = bar; } }

As I read, Scala immutable val doesn't get translated to Java final for various reasons. Does this mean that accessing a val from an other Thread must be guarded with synchronization in order to guarantee visibility? As object members, once initialized, val s never change their values during the lifetime of the object. As such, their values are guaranteed to be visible to all threads provided that the reference to the object didn't escape in the constructor. And, in fact, they get Java final modifiers as illustrated below: object Obj { val r = 1 def foo { val a = 1 def bar = a bar } } Using

Let's say I have the following, public class Foo{ private String bar; public String getBar(){ return bar; } public void setBar(String bar){ this.bar = bar; } } Are these methods automatically threadsafe due to the immutable nature of the String class, or is some locking mechanism required? No, this is not threadsafe. Foo is mutable, so if you want to ensure that different threads see the same value of bar – that is, consistency – either: Make bar volatile , or Make the methods synchronized , or Use an AtomicReference<String> . The reads and writes of bar are themselves atomic, but atomicity is

While checking the source code of Java's BigDecimal class, I was surprised that it was not declared as a final class : Class BigDecimal public class BigDecimal extends Number implements Comparable<BigDecimal> Immutable , arbitrary-precision signed decimal numbers. (from the Oracle Docs ) Is there a specific reason for this or did the developers just forget to add that keyword? Is it a good practice to not declare immutable classes as final? The same goes for BigInteger , but not for String which is declared as final. Quote from https://blogs.oracle.com/darcy/entry/compatibly_evolving