There are two aspects to your questions: what are the technical aspects of using const instead of var and what are the human-related aspects of doing so. The technical difference is significant. In compiled languages, a constant will be replaced at compile-time and its use will allow for other optimizations like dead code removal to … Read more
Well, there are a few aspects to this. Mutable objects without reference-identity can cause bugs at odd times. For example, consider a Person bean with a value-based equals method: Map<Person, String> map = … Person p = new Person(); map.put(p, “Hey, there!”); p.setName(“Daniel”); map.get(p); // => null The Person instance gets “lost” in the map … Read more
In general, methods that end in ! indicate that the method will modify the object it’s called on. Ruby calls these as “dangerous methods” because they change state that someone else might have a reference to. Here’s a simple example for strings: foo = “A STRING” # a string called foo foo.downcase! # modifies foo … Read more
Immutable means that once the constructor for an object has completed execution that instance can’t be altered. This is useful as it means you can pass references to the object around, without worrying that someone else is going to change its contents. Especially when dealing with concurrency, there are no locking issues with objects that … Read more
CPython does not promise to intern all strings by default, but in practice, a lot of places in the Python codebase do reuse already-created string objects. A lot of Python internals use (the C-equivalent of) the sys.intern() function call to explicitly intern Python strings, but unless you hit one of those special cases, two identical … Read more
Instances of immutable types are inherently thread-safe, since no thread can modify it, the risk of a thread modifying it in a way that interferes with another is removed (the reference itself is a different matter). Similarly, the fact that aliasing can’t produce changes (if x and y both refer to the same object a … Read more
Before proceeding further with the fuss of immutability, let’s just take a look into the String class and its functionality a little before coming to any conclusion. This is how String works: String str = “knowledge”; This, as usual, creates a string containing “knowledge” and assigns it a reference str. Simple enough? Lets perform some … Read more
Strings in Python are immutable (can’t be changed). Because of this, the effect of line.replace(…) is just to create a new string, rather than changing the old one. You need to rebind (assign) it to line in order to have that variable take the new value, with those characters removed. Also, the way you are … Read more
str is not an object, it’s a reference to an object. “Hello” and “Help!” are two distinct String objects. Thus, str points to a string. You can change what it points to, but not that which it points at. Take this code, for example: String s1 = “Hello”; String s2 = s1; // s1 and … Read more
Normal assignment operations will simply point the new variable towards the existing object. The docs explain the difference between shallow and deep copies: The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances): A shallow copy constructs a new compound object and … Read more