Clean way to use mutable implementation of Immutable interfaces for encapsulation
My code is working on some compost relationship which creates a tree structure, class A has many children of type B, which has many children of type C etc. The lowest level class, call it bar, also points to a connected bar class. This effectively makes nearly every object in my domain inter-connected. Immutable objects would be problematic due to the expense of rebuilding almost all of my domain to make a single change to one class.
Clean way to use mutable implementation of Immutable interfaces for encapsulation
My code is working on some compost relationship which creates a tree structure, class A has many children of type B, which has many children of type C etc. The lowest level class, call it bar, also points to a connected bar class. This effectively makes nearly every object in my domain inter-connected. Immutable objects would be problematic due to the expense of rebuilding almost all of my domain to make a single change to one class.
Clean way to use mutable implementation of Immutable interfaces for encapsulation
My code is working on some compost relationship which creates a tree structure, class A has many children of type B, which has many children of type C etc. The lowest level class, call it bar, also points to a connected bar class. This effectively makes nearly every object in my domain inter-connected. Immutable objects would be problematic due to the expense of rebuilding almost all of my domain to make a single change to one class.
Clean way to use mutable implementation of Immutable interfaces for encapsulation
My code is working on some compost relationship which creates a tree structure, class A has many children of type B, which has many children of type C etc. The lowest level class, call it bar, also points to a connected bar class. This effectively makes nearly every object in my domain inter-connected. Immutable objects would be problematic due to the expense of rebuilding almost all of my domain to make a single change to one class.
Is immutability very worthwhile when there is no concurrency?
It seems that thread-safety is always/often mentioned as the main benefit of using immutable types and especially collections.
Is immutability very worthwhile when there is no concurrency?
It seems that thread-safety is always/often mentioned as the main benefit of using immutable types and especially collections.
Controllers passing Request objects to backend logic that forward Request data: Good or Bad?
Currently working on a server-side front-end Scala Play app that does a lot of grabbing of HTML snippets and JSON from many other web apps before piecing everything together and sending it in a response to the browser.
Immutable objects [closed]
Closed 9 years ago.
Tell, Don’t Ask and Immutability in a non-directional network
I’m working on a small project in which I’m attempting to practice relatively strict adherence to two ideas:
Tell, Don’t Ask and Immutability in a non-directional network
I’m working on a small project in which I’m attempting to practice relatively strict adherence to two ideas: