This article enumerates ten classic mistakes when handling Python strings—covering immutability, identity vs equality, truthiness of empty values, misuse of strip and split, Unicode length, performance of concatenation, encoding issues, and trailing backslashes—to help developers write safer, more efficient code.
This article explains why returning multiple values in Java can be cumbersome, introduces Apache Commons Lang3’s Pair and Triple utilities—including mutable and immutable variants—shows how to add the Maven dependency, and provides clear code examples that demonstrate their creation, modification, and safe usage in real‑world scenarios.
This article explains what Python dataclasses are, how they simplify data‑oriented class definitions, and demonstrates advanced features like custom field behavior, the __post_init__ method, and immutable (frozen) classes with clear code examples.
Python’s augmented assignment operators like += look simple, but their behavior varies dramatically between mutable and immutable objects, affecting performance and causing surprising bugs; this article explains the underlying data model, demonstrates with tuples, lists, and mixed structures, and reveals the hidden mechanics behind in‑place and object‑creation operations.
This guide explains Python tuples—immutable ordered collections—covering their definition, creation methods (including packing, unpacking, and single-element tuples), element access, common operations like concatenation, repetition, slicing, membership testing, length retrieval, nesting, and built‑in methods such as count, index, and conversion from lists.
Apache Commons Lang3 provides Pair and Triple classes that let Java developers return multiple related values without custom wrappers, offering immutable and mutable variants, easy Maven integration, and clear APIs for handling key‑value pairs and three‑element tuples, improving code readability and maintainability.
This article explains what makes a class thread‑safe in Java, illustrates common race‑condition pitfalls with sample code, and presents six practical design strategies—including stateless, immutable, synchronized, volatile, concurrent collections, thread‑confinement, and defensive copying—to help developers build robust, high‑performance concurrent applications.
This article explains the differences between Python lists and tuples, covering their definitions, mutable vs immutable nature, syntax, performance, common pitfalls, and best-use scenarios such as dynamic collections, fixed data, and dictionary keys, with clear code examples.
This article introduces Python tuples, explaining their immutable ordered nature, core characteristics, and provides eleven practical code examples ranging from basic definition and indexing to unpacking, concatenation, using tuples as dictionary keys, and converting them to lists, illustrating common use cases and best practices.
This article explains the Java BigDecimal class, detailing its internal storage mechanisms, precision handling, immutable design, and common pitfalls, and provides best‑practice guidelines for constructing, comparing, dividing, and converting BigDecimal values to ensure accurate numerical computations.
This article provides a step‑by‑step guide to Java concurrency, covering core concepts such as threads, runnables, thread lifecycle, synchronization primitives, wait/notify patterns, volatile variables, ThreadLocal storage, and how to design immutable objects for thread‑safety, all illustrated with concrete code examples and detailed explanations.
This article details the design, three major benefits, optimization steps, and extensive benchmark results of the limu immutable data library, demonstrating how meta handling, prototype manipulation, and Map‑based storage dramatically improve performance compared to other libraries such as immer, mutative, and structura.
The article explains how the Value Object pattern, combined with PHP 8.1/8.2 features like readonly properties and named arguments, can eliminate primitive‑type validation duplication, prevent parameter‑order mistakes, and ensure immutability, thereby making PHP code more robust, maintainable, and self‑documenting.
This article explains the memory‑management differences between mutable and immutable Python objects, demonstrates how each type behaves with code examples, and shows how immutability improves thread safety while providing practical synchronization techniques for mutable data in concurrent programs.
This article outlines seven essential practices for creating immutable Java classes, including declaring the class as final, using private final fields, omitting setters, performing deep copies, overriding equals() and hashCode(), avoiding this‑escape in constructors, and protecting against reflective modification.
This article explains Java thread‑safety concepts, classifies five safety levels from immutable to thread‑hostile, and details synchronization techniques—including mutual exclusion, non‑blocking CAS, and no‑sync approaches like reentrant code and thread‑local storage—to help developers write safe concurrent code.
This article introduces Google Guava's powerful utilities—including Joiner, Splitter, CharMatcher, primitive type extensions, Multiset, Immutable collections, Multimap, BiMap, Table, functional Functions, Predicate, null‑checking, local caching, and asynchronous callbacks—demonstrating how they simplify Java development and improve code readability and safety.
This article explains what immutable data structures are, outlines their advantages such as reduced complexity, memory savings, easy state rollback, and functional programming benefits, and demonstrates practical usage of Immutable.js in React components and Redux integration with code examples and best‑practice tips.
This article explains Python’s core principle that everything is an object, detailing the distinction between type objects, instance objects, and metaclasses, how built‑in types like int and str fit into the hierarchy, the role of the object base class, variable naming as pointers, and the differences between mutable, immutable, fixed‑length and variable‑length objects.
This article introduces the core features of Google Guava—including Joiner, Splitter, CharMatcher, primitive type helpers, Multiset, immutable collections, Multimap, BiMap, Table, functional utilities like Functions and Predicates, Optional, Preconditions, and a powerful local Cache—showcasing how they simplify Java development and improve code readability, safety, and performance.
This article explores Python’s core concept that everything is an object, explaining how variables reference objects, the role of the id() and type() functions, and the differences between mutable and immutable objects with practical code examples.
This article explains how Java's Optional class provides a lightweight proxy for null values, preventing NullPointerExceptions, and demonstrates best‑practice patterns for immutable objects, field validation, and clean API design with concrete code examples.
This article explains the Stage‑1 JavaScript Record & Tuple proposal, showing how the new immutable value types are created with a leading #, how they differ from objects by using value‑based comparison, and why they improve deep equality, sharing, non‑destructive updates, and usage in Maps and Sets.
This guide explains the Linux chattr command, showing how to add immutable or append‑only attributes to files and directories, verify the settings, and later remove the protection, with practical examples and command syntax.
This article explains why Java's Arrays.asList and List.subList can produce unexpected behavior, how mutable and immutable List implementations interact with their backing arrays, and provides safe alternatives and best practices to prevent ConcurrentModificationException and hidden memory leaks.
This article explains Python tuples, contrasting them with lists, covering their immutable nature, how they enable functions to return multiple values, performance advantages, creation syntax, updating via slicing, deletion, and membership operations, all illustrated with clear code examples.
This article explains Python tuples as immutable ordered collections, covering their creation, indexing (including negative indices), slicing with optional stride, concatenation and replication operators, and useful built‑in functions such as len, max, and min, while contrasting tuples with lists.
This article explains Groovy's immutable Tuple classes, shows how to create and use Tuple, Tuple2, Tuple3, and demonstrates their read‑only behavior with practical code examples, highlighting why they are ideal for returning multiple values from methods.
This article lists the ten most common errors Java developers make, explains why each is problematic, and provides clear code examples and best‑practice alternatives to help you write safer, more efficient Java code.
At a GitHub China meetup, the author reflects on Rich Harris’s critique of React, compares mutable versus immutable reactivity in Vue and React, examines functional programming foundations, and proposes a unified approach integrating mutable, immutable, and reactive patterns to transcend framework paradigm disputes.
This article explains why using Java's Arrays.asList with primitive arrays can produce unexpected list sizes, why the resulting list is immutable, and provides correct usage patterns with code examples to avoid UnsupportedOperationException and other bugs.
This article explains Python's object model, the difference between mutable and immutable objects, how references work, and provides clear examples of shallow and deep copying—including when each method should be used to avoid unintended data modification.
This article introduces Scala's collection library, explaining the distinction between mutable and immutable collections and detailing common types such as List, Set, Map, Tuple, Option, and Iterator, accompanied by example code for each.
This tutorial explains how Scala treats strings as immutable Java objects, shows how to create and modify strings using literals, explicit types, and StringBuilder, demonstrates length retrieval, concatenation, formatted output, and provides a comprehensive list of java.lang.String methods usable in Scala.
This article introduces Python 3 tuples as immutable ordered collections, explains how to create, index, slice, concatenate, and replicate them, and demonstrates built‑in functions such as len, max, and min while comparing tuples with lists and showing conversion techniques.
This article explains Python's frozenset type, detailing its immutable nature, creation syntax, differences from mutable sets, supported operations, membership testing, and practical code examples illustrating set algebra and method usage.
This article explains Python's id() function, how objects and references work, and demonstrates parameter passing behavior with detailed code examples illustrating memory address handling for immutable and mutable types, including lists, integers, and strings, and clarifies why variable assignments may share the same address.
This article explains Python's variable storage model and demonstrates how assignment, shallow copy, and deep copy affect object references and memory addresses for immutable and mutable types, using string and list examples to illustrate the differences.
This article explains Java's String class, covering its automatic import, how to create string objects without the new keyword, concatenation, immutability, common methods like replace, and provides useful API references and code examples for practical use.
This article explains the difference between immutable and mutable objects in Python, using clear examples to show why modifying a list parameter inside a function changes the original variable while altering a number does not, helping beginners master function arguments and avoid common interview pitfalls.
This article describes how the YIcon project tackled severe React performance bottlenecks—such as repeated renders, slow diffing, and inefficient key usage—by applying shouldComponentUpdate, component splitting, immutable data structures, stable keys, and production‑grade webpack optimizations, ultimately achieving an 80% speed gain.
