immutability

The advantages of immutable objects in Java seem clear: consistent state automatic thread safety simplicity You can favour immutability by using private final fields and constructor injection. But, what are the downsides to favouring immutable objects in Java? i.e. incompatibility with ORM or web presentation tools? Inflexible design? Implementation complexities? Is it possible to design a large-scale system (deep object graph) that predominately uses immutable objects? dfa But, what are the downsides to favouring immutable objects in Java? incompatibility with ORM or web presentation tools?

I've been studying Java String for a while. The following questions are based on the below posts Java String is special Immutability of String in java Immutability: Now, going by the immutability, the String class has been designed so that the values in the common pool can be reused in other places/variables. This holds good if the String was created as String a = "Hello World!"; However, if I create String like String b = new String("Hello World!"); why is this immutable as well? (or is it?). Since this has a dedicated heap memory, I should be able to modify this without affecting any other

I recently listened to Rich Hickey's interview on Software Engineering Radio . During the interview Rich mentioned that Clojure's collections are implemented as trees. I'm hoping to implement persistent data structures in another language, and would like to understand how sets and Clojure's other persistent data structures are implemented. What would the tree look like at each point in the following scenario? Create the set {1 2 3} Create the union of {1 2 3} and {4} Create the difference of {1 2 3 4} and {1} I'd like to understand how the three sets generated ( {1 2 3} , {1 2 3 4} , and {2 3

This is the rspec binstub in my project directory. #!/usr/bin/env ruby begin load File.expand_path("../spring", __FILE__) rescue LoadError end # frozen_string_literal: true # # This file was generated by Bundler. # # The application 'rspec' is installed as part of a gem, and # this file is here to facilitate running it. # require "pathname" ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", Pathname.new(__FILE__).realpath) require "rubygems" require "bundler/setup" load Gem.bin_path("rspec-core", "rspec") What is this intended to do? # frozen_string_literal: true # frozen_string

Consider a case where I change the kwargs dict inside a method: def print_arg(**kwargs): print kwargs.pop('key') If I call the method pop_arg with a dictionary like this: mydict = {'key':'value'} print_arg(**mydict) will mydict be changed by this call? I am also interested in a more detailed explanation of the underlying method calling mechanism that lets mydict change or not. Let's see: import dis dis.dis(lambda: print_arg(**{'key': 'value'})) 6 0 LOAD_GLOBAL 0 (print_arg) 3 BUILD_MAP 1 6 LOAD_CONST 1 ('value') 9 LOAD_CONST 2 ('key') 12 STORE_MAP 13 CALL_FUNCTION_KW 0 16 RETURN_VALUE Let's

I want to remove a element from my redux state. Im using seamless-immutable and its API to operate on the state. But I couldn't find any nice looking way to delete a element when the state is nested. So the element I want to delete is: state.shoppingcartReducer.products[articleNr] Thanks! import Immutable from 'seamless-immutable' import { addToShoppingcart, createShoppingCart } from '../actions/shoppingcartActions' const CREATE_SHOPPING_CART = 'CREATE_SHOPPING_CART' const ADD_PRODUCT = 'ADD_PRODUCT' const DELETE_PRODUCT = 'DELETE_PRODUCT' const UPDATE_QUANTITY = 'UPDATE_QUANTITY' const

It is possible to create a DeepReadonly type like this: type DeepReadonly<T> = { readonly [P in keyof T]: DeepReadonly<T[P]>; }; interface A { B: { C: number; }; D: { E: number; }[]; } const myDeepReadonlyObject: DeepReadonly<A> = { B: { C: 1 }, D: [ { E: 2 } ], } myDeepReadonlyObject.B = { C: 2 }; // error :) myDeepReadonlyObject.B.C = 2; // error :) This is great. Both B and B.C are readonly. When I try to modify D however... // I'd like this to be an error myDeepReadonlyObject.D[0] = { E: 3 }; // no error :( How should I write DeepReadonly so that nested arrays are readonly as well? As of