immutability

I have been exploring Room database object mapping library and I figured something weird. An entity data model cannot have immutable properties, as this answer suggests. But I checked out google's persistent example with kotlin , Room works with immutable properties too. Please check this data class from the example. What could be the reason for this behavior? This could be a good feature if we could create immutable values ( val properties), as this restrict programmers from changing unique identifiers such as ids after an object has been created. It's weird because I can make my Entity class

Our application uses plenty of dictionaries which have multi level lookup that are not frequently changing. We are investigating at converting some of the critical code that does a lot of lookup using dictionaries to use alternate structures for - faster lookup, light on the memory/gc. This made us compare various dictionaries/libraries available - Dictionary ( System.Collections.Generics.Dictionary -SCGD), ImmutableDictionary , C5.HashDictionary , FSharpMap . Running the following program with various items count - 100, 1000, 10000, 100000 - shows that Dictionary is still the winner at most

I distinctly remember from the early days of .NET that calling ToString on a StringBuilder used to provide the new string object (to be returned) with the internal char buffer used by StringBuilder. This way if you constructed a huge string using StringBuilder, calling ToString didn't have to copy it. In doing that, the StringBuilder had to prevent any additional changes to the buffer, because it was now used by an immutable string. As a result the StringBuilder would switch to a "copy-on-change" made where any attempted change would first create a new buffer, copy the content of the old

I'm doing some distributed computing in which several machines communicate under the assumption that they all have identical versions of various classes. Thus, it seems to be good design to make these classes immutable; not in the sense that it must thwart a user with bad intentions, just immutable enough that it is never modified by accident. How would I go about this? For example, how would I implement a metaclass that makes the class using it immutable after it's definition? >>> class A(object): ... __metaclass__ = ImmutableMetaclass >>> A.something = SomethingElse # Don't want this >>> a =

Given that mutable structs are generally regarded as evil (e.g., Why are mutable structs “evil”? ), are there potential benefits that might have prompted the designers of the .NET framework to make System.Windows.Point & System.Windows.Vector mutable? I'd like to understand this so I can decide whether it would make sense to make my own similar structs mutable (if ever). It's possible the decision to make Point and Vector mutable was just an error in judgment, but if there was a good reason (e.g., a performance benefit), I'd like to understand what it was. I know that I've stumbled over the

Is there any way of using an immutable object as a model within a view-state in Spring webflow? I know Spring webflow generally tends towards setters for this kind of thing, but I was wondering if anyone knew of a custom DataBinder or WebDataBinder that could handle binding the data using a constructor? I'm also aware there's this (SPR-1488) JIRA task against the problem, which advocated direct field access. Do people advocate this way of doing things? To me it doesn't quite feel right. Thanks, Stuart I have put an example of how you can do this using Jackson's ObjectMapper (which besides JSON

I am trying to determine what the best practices would be for an ImmutableList. Below is a simplistic example that will help drive my questions: Ex: public ImmutableCollection<Foo> getFooOne(ImmutableList<Foo> fooInput){ //.. do some work ImmutableList<Foo> fooOther = // something generated during the code return fooOther; } public Collection<Foo> getFooTwo(List<Foo> fooInput){ //.. do some work List<Foo> fooOther = // something generated during the code return ImmutableList.copyOf(fooOther); } public void doSomethingOne(){ ImmutableCollection<Foo> myFoo = getFooOne(myList); ...