# immutability

Published articles for immutability.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Value Classes Still Need Compiler Sympathy

DevFeed: [Value Classes Still Need Compiler Sympathy](<https://devfeed.tech/articles/value-classes-still-need-compiler-sympathy-15126.md>)

Original publisher: [Read original article](<https://inside.java/2026/08/24/value-classes-compiler-sympathy/>)

Author: Johan Sjölén

Published: 2026-08-24T00:00:00Z

Content type: article

Language: en

Sources: [Inside Java](<https://devfeed.tech/sources/inside-java.md>)

Topics: [JDK 28](<https://devfeed.tech/topics/jdk-28.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [jdk-28](<https://devfeed.tech/tags/jdk-28.md>), [jep-401](<https://devfeed.tech/tags/jep-401.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [openjdk](<https://devfeed.tech/tags/openjdk.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [payload](<https://devfeed.tech/tags/payload.md>), [profiling](<https://devfeed.tech/tags/profiling.md>), [project-valhalla](<https://devfeed.tech/tags/project-valhalla.md>), [valhalla](<https://devfeed.tech/tags/valhalla.md>)

### AI overview

This article examines value classes as a preview feature in JDK 28 and explains how giving up object identity can enable JVM optimizations such as flattening and scalarization. It also describes limitations caused by representation changes, abstraction boundaries, mutability, and generic virtual calls.

### Source excerpt

Declaring a value class is first and foremost a semantic decision. It tells our fellow programmers that its instances are defined entirely by their state and do not need identity. That clearer model is valuable in itself! The JVM's additional freedom to optimize how those values are represented is a welcome bonus. C2 can do amazing things with that freedom, but it cannot always recover information hidden behind abstraction boundaries. Profiling and inspecting the generated code remain the best ways to understand what is happening. To get the best results, we may still need to have a little sympathy for the compiler.

## Immutability in PHP Beyond readonly

DevFeed: [Immutability in PHP Beyond readonly](<https://devfeed.tech/articles/immutability-in-php-beyond-readonly-33295.md>)

Original publisher: [Read original article](<https://freek.dev/3181-immutability-in-php-beyond-readonly>)

Author: Freek Van der Herten (freek@spatie.be)

Published: 2026-08-17T12:12:30Z

Content type: article

Language: en

Sources: [freek.dev - all blogposts](<https://devfeed.tech/sources/freek-dev-all-blogposts.md>)

Topics: [PHP](<https://devfeed.tech/topics/php.md>)

Tags: [best-practices](<https://devfeed.tech/tags/best-practices.md>), [deep-dive](<https://devfeed.tech/tags/deep-dive.md>), [design-patterns](<https://devfeed.tech/tags/design-patterns.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [php](<https://devfeed.tech/tags/php.md>), [properties](<https://devfeed.tech/tags/properties.md>), [value](<https://devfeed.tech/tags/value.md>), [value-objects](<https://devfeed.tech/tags/value-objects.md>)

### AI overview

A deep dive into immutability in PHP, covering readonly properties, interior mutability, immutable value objects and collections, dates, cloning, boundaries, and testing.

### Source excerpt

A deep dive into immutability in PHP, from readonly properties and interior mutability to immutable value objects, collections, dates, cloning, boundaries, and testing. Read more

## Changing Immutable Collections

DevFeed: [Changing Immutable Collections](<https://devfeed.tech/articles/changing-immutable-collections-30704.md>)

Original publisher: [Read original article](<https://codeblog.jonskeet.uk/2025/12/31/changing-immutable-collections/>)

Author: jonskeet

Published: 2025-12-31T10:32:45Z

Content type: article

Language: en

Sources: [Jon Skeet](<https://devfeed.tech/sources/jon-skeet.md>)

Topics: [C#](<https://devfeed.tech/topics/csharp.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [array](<https://devfeed.tech/tags/array.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [blog](<https://devfeed.tech/tags/blog.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [collection](<https://devfeed.tech/tags/collection.md>), [election-2029](<https://devfeed.tech/tags/election-2029.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [linq](<https://devfeed.tech/tags/linq.md>), [migration](<https://devfeed.tech/tags/migration.md>), [properties](<https://devfeed.tech/tags/properties.md>)

### AI overview

The article explains a migration from ImmutableList<T> and ImmutableDictionary<TKey, TValue> to immutable collection types better suited to code that creates collections and then leaves them unchanged. It describes the migration steps and related helper-method and property-type changes.

### Source excerpt

As I've written before, I'm leaning heavily into immutability in the election site code. Until September 2025 (it's taken a long time to get round to writing this blog post) that meant a combination of records, ImmutableList<T> and ImmutableDictionary<TKey, TValue>. In an ECMA C# standards meeting, however, Joseph Musser passed on some really valuable feedback ... Continue reading Changing Immutable Collections ->

## The principle of immutability

DevFeed: [The principle of immutability](<https://devfeed.tech/articles/the-principle-of-immutability-13266.md>)

Original publisher: [Read original article](<https://www.chainguard.dev/unchained/the-principle-of-immutability>)

Published: 2024-08-20T00:00:00Z

Content type: opinion

Language: en

Sources: [Chainguard: Unchained](<https://devfeed.tech/sources/chainguard-unchained.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [rust](<https://devfeed.tech/tags/rust.md>), [secure-by-default](<https://devfeed.tech/tags/secure-by-default.md>), [secure-by-design](<https://devfeed.tech/tags/secure-by-design.md>)

### AI overview

The article argues that immutability is about intentionally controlling change rather than preventing change. It presents immutability by default as part of secure-by-design software and compares approaches in functional programming, C++, and Rust.

### Source excerpt

Secure by default starts with immutability. Discover how to control change and minimize risks.

## Best practices for patching and deprecating Docker images

DevFeed: [Best practices for patching and deprecating Docker images](<https://devfeed.tech/articles/best-practices-for-patching-and-deprecating-docker-images-27696.md>)

Original publisher: [Read original article](<https://gagor.pro/2024/02/best-practices-for-patching-and-deprecating-docker-images/>)

Author: Tom

Published: 2024-02-09T00:00:00Z

Content type: tutorial

Language: en

Sources: [Tomasz Gągor](<https://devfeed.tech/sources/tomasz-gagor.md>)

Topics: [Docker](<https://devfeed.tech/topics/docker.md>), [Docker Image](<https://devfeed.tech/topics/docker-image.md>), [Security](<https://devfeed.tech/topics/security.md>), [DevOps](<https://devfeed.tech/topics/devops.md>)

Tags: [best-practices](<https://devfeed.tech/tags/best-practices.md>), [devops](<https://devfeed.tech/tags/devops.md>), [devops-docker-management](<https://devfeed.tech/tags/devops-docker-management.md>), [docker](<https://devfeed.tech/tags/docker.md>), [docker-image](<https://devfeed.tech/tags/docker-image.md>), [docker-image-deprecation](<https://devfeed.tech/tags/docker-image-deprecation.md>), [docker-image-maintenance](<https://devfeed.tech/tags/docker-image-maintenance.md>), [docker-image-patching](<https://devfeed.tech/tags/docker-image-patching.md>), [docker-security-best-practices](<https://devfeed.tech/tags/docker-security-best-practices.md>), [docker-update-strategies](<https://devfeed.tech/tags/docker-update-strategies.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [linux](<https://devfeed.tech/tags/linux.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

This article presents practices for maintaining Docker images securely and predictably. It recommends deprecating images before deleting them, notifying users of upcoming breaking changes, upgrading base images quarterly, and pinning versions to keep rebuilds stable.

### Source excerpt

Learn the best practices for patching and deprecating Docker images to maintain security and stability in your DevOps workflows.

## Oxidizing OCaml: Rust-Style Ownership

DevFeed: [Oxidizing OCaml: Rust-Style Ownership](<https://devfeed.tech/articles/oxidizing-ocaml-rust-style-ownership-20201.md>)

Original publisher: [Read original article](<https://blog.janestreet.com/oxidizing-ocaml-ownership/>)

Author: Max Slater

Published: 2023-06-21T00:00:00Z

Content type: article

Language: en

Sources: [Jane Street](<https://devfeed.tech/sources/jane-street.md>)

Topics: [OCaml](<https://devfeed.tech/topics/ocaml.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [functional](<https://devfeed.tech/tags/functional.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [ocaml](<https://devfeed.tech/tags/ocaml.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

This article examines ownership modes in OCaml with Jane Street extensions. It explains how unique references can allow in-place updates while preserving an immutable interface, and discusses how uniqueness may support static prevention of data races in multicore OCaml.

### Source excerpt

OCaml with Jane Street extensions is available from our public opam repo. Only a slice of the features described in this series are currently implemented.

## Platonic C# - Managing Referential Transparency through Unique Types

DevFeed: [Platonic C# - Managing Referential Transparency through Unique Types](<https://devfeed.tech/articles/platonic-c-managing-referential-transparency-through-unique-types-29491.md>)

Original publisher: [Read original article](<http://lambda-the-ultimate.org/node/5666>)

Published: 2023-03-04T20:11:56Z

Content type: opinion

Language: en

Sources: [Lambda the Ultimate](<https://devfeed.tech/sources/lambda-the-ultimate.md>)

Topics: [C#](<https://devfeed.tech/topics/csharp.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [context](<https://devfeed.tech/topics/context.md>)

Tags: [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [context](<https://devfeed.tech/tags/context.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [object-functional](<https://devfeed.tech/tags/object-functional.md>)

### AI overview

The article proposes Platonic C# as a set of rules intended to enforce referential transparency by defaulting to immutable data structures and requiring unique instances of mutable types.

### Source excerpt

The idea of Platonic C# is to enforce referential transparency within the context of C#, by enforcing a set of rules around defaulting to immutability of data structures and requiring uniqueness of instances of mutable types.

## A birds-eye view of Arrow: Data Immutability with Arrow Optics

DevFeed: [A birds-eye view of Arrow: Data Immutability with Arrow Optics](<https://devfeed.tech/articles/a-birds-eye-view-of-arrow-data-immutability-with-arrow-optics-39301.md>)

Original publisher: [Read original article](<https://kt.academy/article/fk-arrow-optics>)

Published: 2022-12-19T00:15:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [API](<https://devfeed.tech/topics/api.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [arrow](<https://devfeed.tech/tags/arrow.md>), [code](<https://devfeed.tech/tags/code.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [ksp](<https://devfeed.tech/tags/ksp.md>), [lens](<https://devfeed.tech/tags/lens.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This tutorial introduces Arrow Optics for transforming nested immutable data in Kotlin. It explains how Arrow Optics uses a basic library and a compiler plug-in built with Kotlin Symbol Processing, with annotations generating lenses that combine getters and setters.

### Source excerpt

Learn to use Arrow Optics to support working on immutable objects.

## Object-oriented or functional? Two ways to see the world

DevFeed: [Object-oriented or functional? Two ways to see the world](<https://devfeed.tech/articles/object-oriented-or-functional-two-ways-to-see-the-world-39357.md>)

Original publisher: [Read original article](<https://kt.academy/article/oop-vs-fp>)

Published: 2022-08-18T00:00:00Z

Content type: opinion

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [fp](<https://devfeed.tech/tags/fp.md>), [functional](<https://devfeed.tech/tags/functional.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [oop](<https://devfeed.tech/tags/oop.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This opinion article compares object-oriented programming and functional programming as ways of thinking about program design, rather than merely collections of features. It uses different ways of viewing a bedroom--as objects or actions--to illustrate the distinction while acknowledging that modern languages commonly support both styles.

### Source excerpt

The difference between the OOP and FP paradigms is deeply rooted in how we see the world. A few words on the philosophy of both approaches.

## Apollo Kotlin: New Multiplatform Memory Manager

DevFeed: [Apollo Kotlin: New Multiplatform Memory Manager](<https://devfeed.tech/articles/apollo-kotlin-new-multiplatform-memory-manager-23202.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/apollo-kotlin-new-multiplatform-memory-manager>)

Author: Benoit Lubek

Published: 2022-08-09T12:05:22Z

Content type: news

Language: en

Sources: [Apollo Blog](<https://devfeed.tech/sources/apollo-blog.md>)

Topics: [Kotlin Multiplatform](<https://devfeed.tech/topics/kotlin-multiplatform.md>), [kotlin-multiplatform-libraries](<https://devfeed.tech/topics/kotlin-multiplatform-libraries.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [apollo](<https://devfeed.tech/tags/apollo.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [kotlin-native](<https://devfeed.tech/tags/kotlin-native.md>), [library](<https://devfeed.tech/tags/library.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [multithreading](<https://devfeed.tech/tags/multithreading.md>), [performance](<https://devfeed.tech/tags/performance.md>), [unit-tests](<https://devfeed.tech/tags/unit-tests.md>)

### AI overview

Apollo Kotlin 3.5.0 adopts Kotlin Native's new memory manager. The change removes several threading and immutability restrictions, including the requirement to access the library exclusively from the Main thread on Apple targets. Initial benchmarks indicate performance improvements of up to 45%.

### Source excerpt

Back in May, we shared about how Apollo Kotlin started supporting the Hierarchical project structure. Following the Kotlin Multiplatform ecosystem, here is some more news, this time about the new Memory Manager. Kotlin Native's Memory Manager Since its early days, Kotlin Native has had specific rules regarding multithreading and immutability: - objects could only be accessed from the thread they were created in - unless they had been "frozen", in which case they could be accessed by multiple...

## Data is immutable

DevFeed: [Data is immutable](<https://devfeed.tech/articles/data-is-immutable-37568.md>)

Original publisher: [Read original article](<https://blog.klipse.tech/databook/2022/06/22/immutable-data.html>)

Author: Yehonathan Sharvit

Published: 2022-06-22T02:34:24Z

Content type: article

Language: en

Sources: [Klipse](<https://devfeed.tech/sources/klipse.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [clojure](<https://devfeed.tech/tags/clojure.md>), [d](<https://devfeed.tech/tags/d.md>), [data](<https://devfeed.tech/tags/data.md>), [dop](<https://devfeed.tech/tags/dop.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [mutation](<https://devfeed.tech/tags/mutation.md>)

### AI overview

This article explains the third principle of Data-Oriented Programming: data is immutable. It describes replacing mutation with new data versions, contrasts this approach in Clojure and JavaScript, and discusses cloning and persistent data structures as implementation strategies.

### Source excerpt

With data separated from code and represented with generic data structures, how are changes to the data managed? DOP is very strict on this question. Mutation of data is not allowed! In DOP, changes to data are accomplished by creating new versions of the data. The reference to a variable may be changed so that it refers to a new version of the data, but the value of the data itself must never change.

## Represent data with generic data structures

DevFeed: [Represent data with generic data structures](<https://devfeed.tech/articles/represent-data-with-generic-data-structures-37567.md>)

Original publisher: [Read original article](<https://blog.klipse.tech/databook/2022/06/22/generic-data-structures.html>)

Author: Yehonathan Sharvit

Published: 2022-06-22T02:33:24Z

Content type: article

Language: en

Sources: [Klipse](<https://devfeed.tech/sources/klipse.md>)

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Code](<https://devfeed.tech/topics/code.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [array](<https://devfeed.tech/tags/array.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [code](<https://devfeed.tech/tags/code.md>), [d](<https://devfeed.tech/tags/d.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [dop](<https://devfeed.tech/tags/dop.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [oop](<https://devfeed.tech/tags/oop.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

This article explores the second principle of Data-Oriented Programming: representing application data with generic data structures such as maps and arrays instead of specific classes. It also discusses other structures, including sets, trees, and queues, and describes benefits such as reusable generic functions and a flexible data model.

### Source excerpt

When adhering to Principle #1 of DOP, code is separated from data. DOP is not opinionated about the programming constructs to use for organizing the code, but it has a lot to say about how the data should be represented. This is the theme of Principle #2.

## Immutability we can afford

DevFeed: [Immutability we can afford](<https://devfeed.tech/articles/immutability-we-can-afford-26022.md>)

Original publisher: [Read original article](<https://elizarov.medium.com/immutability-we-can-afford-10c0dcb8351d?source=rss-4762e889f8fc------2>)

Author: Roman Elizarov

Published: 2020-07-22T09:18:28Z

Content type: opinion

Language: en

Sources: [Stories by Roman Elizarov on Medium](<https://devfeed.tech/sources/stories-by-roman-elizarov-on-medium.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Software](<https://devfeed.tech/topics/software.md>), [ui](<https://devfeed.tech/topics/ui.md>), [Caching](<https://devfeed.tech/topics/caching.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [caching](<https://devfeed.tech/tags/caching.md>), [code](<https://devfeed.tech/tags/code.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [languages](<https://devfeed.tech/tags/languages.md>), [object](<https://devfeed.tech/tags/object.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [state](<https://devfeed.tech/tags/state.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

The article traces the shift from mutable global state and object-encapsulated state toward immutability. It argues that mutable state becomes difficult to reason about in user interfaces and asynchronous systems, where unexpected mutations complicate debugging, event processing, and caching.

### Source excerpt

Photo by Li Yang on Unsplash At the dawn of software engineering computers were programmed directly in machine code, then in assembly, and only later in higher-level languages. Computers are imperative. They operate by executing instructions that mutate their state, stored in registers and memory. Naturally, the same was true about programming languages. In the old world of expensive computers with limited resources, the primary concern was an efficient translation of higher-level abstractions into low-level code. The past glory of mutable state It used to be a normal practice to write software in a way that mimics the actual computer architecture with thousands of global variables that are being mutated by various pieces of the system. It might be shocking for a modern developer to learn that just recently there were cars on the street, designed as late as 2005, that ran what we would call the "Spaghetti" code. The software industry, in general, had firmly moved past the unruly global state before the end of the last century. The rise of the object-oriented programming paradigm had established an orderly approach with the encapsulation of all the mutable state in our software systems inside of objects. It had fueled tremendous growth in the complexity of modern software, layering abstractions above abstractions, while still maintaining a reasonable degree of human's ability to make sense of it. However, any developer who worked on a non-trivial piece of UI using an object-oriented framework, or had programmed in another domain with lots of asynchronously occurring events, can tell you stories of debugging all those cases where mutable state, even encapsulated into objects, continually trips you. You expect this object to be in a such and such state, but due to some rare sequence of events, it turns out to be in a state you did not expect, having been mutated by another piece of code. For example, take a popular architectural pattern where a repository class encapsu

## \[Перевод\] Архитектурный шаблон MVI в Kotlin Multiplatform, часть 1

DevFeed: [\[Перевод\] Архитектурный шаблон MVI в Kotlin Multiplatform, часть 1](<https://devfeed.tech/articles/mvi-kotlin-multiplatform-1-23610.md>)

Original publisher: [Read original article](<https://habr.com/ru/companies/badoo/articles/501968/>)

Author: arkivanov (Badoo)

Published: 2020-05-14T14:01:02Z

Content type: tutorial

Language: ru

Sources: [Badoo EN](<https://devfeed.tech/sources/badoo-en.md>), [Badoo RU](<https://devfeed.tech/sources/badoo-ru.md>)

Topics: [Kotlin Multiplatform](<https://devfeed.tech/topics/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/topics/multiplatform.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Android](<https://devfeed.tech/topics/android.md>), [iOS](<https://devfeed.tech/topics/ios.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [ios](<https://devfeed.tech/tags/ios.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [kotlin-native](<https://devfeed.tech/tags/kotlin-native.md>), [model-view-intent](<https://devfeed.tech/tags/model-view-intent.md>), [mpp](<https://devfeed.tech/tags/mpp.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [mvi](<https://devfeed.tech/tags/mvi.md>), [mvvm](<https://devfeed.tech/tags/mvvm.md>), [reactive](<https://devfeed.tech/tags/reactive.md>)

### AI overview

This first article in a three-part series describes using the MVI architectural pattern with Kotlin Multiplatform. It introduces a shared module intended for integration with iOS and Android applications and discusses related testing topics. The author argues that MVI is a better fit for Kotlin Multiplatform than MVVM or an added clean-architecture layer, while noting that the article does not teach Kotlin Multiplatform fundamentals or project setup.

### Source excerpt

Около года назад я заинтересовался новой технологией Kotlin Multiplatform. Она позволяет писать общий код и компилировать его под разные платформы, имея при этом доступ к их API. С тех пор я активно экспериментирую в этой области и продвигаю этот инструмент в нашей компании. Одним из результатов, например, является наша библиотека Reaktive -- Reactive Extensions для Kotlin Multiplatform. В приложениях Badoo и Bumble для разработки под Android мы используем архитектурный шаблон MVI (подробнее о нашей архитектуре читайте в статье Zsolt Kocsi: "Современная MVI-архитектура на базе Kotlin"). Работая над различными проектами, я стал большим поклонником этого подхода. Конечно, я не мог упустить возможность попробовать MVI и в Kotlin Multiplatform. Тем более случай был подходящий: нам нужно было написать примеры для библиотеки Reaktive. После этих моих экспериментов я был вдохновлён MVI ещё больше. Я всегда обращаю внимание на то, как разработчики используют Kotlin Multiplatform и как они выстраивают архитектуру подобных проектов. По моим наблюдениям, среднестатистический разработчик Kotlin Multiplatform -- это на самом деле Android-разработчик, который в своей работе использует шаблон MVVM просто потому, что так привык. Некоторые дополнительно применяют "чистую архитектуру". Однако, на мой взгляд, для Kotlin Multiplatform лучше всего подходит именно MVI, а "чистая архитектура" является ненужным усложнением. Поэтому я решил написать эту серию из трёх статей на следующие темы: Краткое описание шаблона MVI, постановка задачи и создание общего модуля с использованием Kotlin Multiplatform. Интеграция общего модуля в iOS- и Android-приложения. Модульное и интеграционное тестирование. Ниже -- первая статья серии. Она будет интересна всем, кто уже использует или только планирует использовать Kotlin Multiplatform.

## Useful Kotlin Features Compared with Java

DevFeed: [Useful Kotlin Features Compared with Java](<https://devfeed.tech/articles/kotlin-useful-but-unfairly-not-mentioned-features-38636.md>)

Original publisher: [Read original article](<https://krossovochkin.com/posts/2020_05_03_kotlin_useful_but_unfairly_not_mentioned_features/>)

Published: 2020-05-03T00:00:00Z

Content type: tutorial

Language: en

Sources: [Vasya Drobushkov](<https://devfeed.tech/sources/vasya-drobushkov.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Java](<https://devfeed.tech/topics/java.md>), [Development](<https://devfeed.tech/topics/development.md>), [Android](<https://devfeed.tech/topics/android.md>)

Tags: [classes](<https://devfeed.tech/tags/classes.md>), [hashcode](<https://devfeed.tech/tags/hashcode.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [java](<https://devfeed.tech/tags/java.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [modifiers](<https://devfeed.tech/tags/modifiers.md>), [package-private](<https://devfeed.tech/tags/package-private.md>), [process](<https://devfeed.tech/tags/process.md>), [smart-cast](<https://devfeed.tech/tags/smart-cast.md>), [visibility](<https://devfeed.tech/tags/visibility.md>)

### AI overview

This article compares Kotlin with Java through several less-discussed language differences. The supplied text covers immutable method-parameter references in Kotlin and contrasts Java visibility modifiers, including protected and package-private access.

### Source excerpt

Source Introduction Many of us first learned Kotlin after Java. Learning process was fairly simple because Kotlin has many similarities when at the same time improves development experience by fighting common pain points Java developer (especially on Java 6, which is common in Android world) has to encounter every day. There are a bunch of articles about cool Kotlin features like immutability, handling nullability, smart-cast, data classes, and so forth. Yes, these features are great. Having to add a bunch of nullability annotations, final keywords, override equals/hashCode methods, create additional local variables after type checks -- all of this adds unnecessary work that needs to be done all the time.

## Using Rust Playground for Hello World and Variable Interpolation

DevFeed: [Using Rust Playground for Hello World and Variable Interpolation](<https://devfeed.tech/articles/using-rust-playground-for-hello-world-and-variable-interpolation-28320.md>)

Original publisher: [Read original article](<http://fuzzyblog.io/blog/rust/2020/03/02/using-rust-playground-for-hello-world-and-variable-interpolation.html>)

Author: Fuzzygroup

Published: 2020-03-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [Scott Johnson](<https://devfeed.tech/sources/scott-johnson.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Code](<https://devfeed.tech/topics/code.md>), [compiled language](<https://devfeed.tech/topics/compiled-language.md>), [Repl.it](<https://devfeed.tech/topics/replit.md>), [browser](<https://devfeed.tech/topics/browser.md>)

Tags: [browser](<https://devfeed.tech/tags/browser.md>), [code](<https://devfeed.tech/tags/code.md>), [compiled-language](<https://devfeed.tech/tags/compiled-language.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [function](<https://devfeed.tech/tags/function.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [language](<https://devfeed.tech/tags/language.md>), [let](<https://devfeed.tech/tags/let.md>), [playground](<https://devfeed.tech/tags/playground.md>), [program](<https://devfeed.tech/tags/program.md>), [run](<https://devfeed.tech/tags/run.md>), [rust](<https://devfeed.tech/tags/rust.md>), [variables](<https://devfeed.tech/tags/variables.md>)

### AI overview

A beginner-oriented walkthrough of using Rust Playground to run a Hello World program and experiment with variables. It explains Rust syntax such as fn, println!, let, and string interpolation, and briefly compares Rust Playground with Repl.it, including a criticism of Repl.it's paid privacy option.

### Source excerpt

Artwork by my friend Autumn Mott; Hopefully I can find a better link to put here It is a Monday and what better way to start your 6 am Monday morning then learning some of the elements of a new language - Rust. I started by adding a link in my Browser toolbar to the Rust Playground which amounts to a web based REPL (Read Evaluate Print Loop) for Rust where you can type in Rust code and run it. Yes I know it really isn't a REPL because Rust is a compiled language not an interpreted one but it functions well enough as a REPL that I can wrap my Ruby tinged mind around it. Here's the Hello World program that automatically appears in the Rust playground fn main() { println!("Hello, world!"); } The output of this is: Hello, world! That's pretty easy to understand: A main function defined with fn A print line function defined with a ! (my previous Rust reading tells me that's a macro indicator) { and } to denote structure A ; to denote the end of lines I wanted to make a simple change to experiment with the use of variables so I added a main2() function and called it from main(): fn main() { println!("Hello, world!"); main2(); } fn main2() { let x = 5; println!("The value of x is: {}", x); let y = 6; println!("The value of y is: {}", y); } The output of this is: Hello, world! The value of x is: 5 The value of y is: 6 You can see that the let keyword assigns a variable and that {} binds a variable into a string (which is generally called interpolation). Note: Variables quickly bring you in to the heart of Rust - immutability - and here there by dragons that hopefully come up tomorrow after some reading. Link Here's a permanent link to this if you want to try it out. What about Repl.it? Another way to have a web based REPL for Rust is Repl.it. And while I like the concept of repl.it, they have eliminated any privacy without a paid account: Upgrade your account for private repls. This appears on the bottom of every new REPL you create and at $74 / 12 months that feels expensi

## On let vs const

DevFeed: [On let vs const](<https://devfeed.tech/articles/on-let-vs-const-36183.md>)

Original publisher: [Read original article](<https://overreacted.io/on-let-vs-const/>)

Published: 2019-12-22T00:00:00Z

Content type: opinion

Language: en

Sources: [Dan Abramov](<https://devfeed.tech/sources/dan-abramov.md>)

Topics: [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Code](<https://devfeed.tech/topics/code.md>), [React Hooks](<https://devfeed.tech/topics/react-hooks.md>)

Tags: [eslint](<https://devfeed.tech/tags/eslint.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [mutation](<https://devfeed.tech/tags/mutation.md>), [react](<https://devfeed.tech/tags/react.md>), [react-hooks](<https://devfeed.tech/tags/react-hooks.md>)

### AI overview

This article examines the debate over using JavaScript let versus const. It summarizes arguments about reducing reassignment-related bugs, teaching mutation and assignment distinctions, React Hooks data flow, performance claims, and preserving intent, then presents the author's personal conclusion.

### Source excerpt

So which one should I use?

## What's new in Apollo Client 2.6

DevFeed: [What's new in Apollo Client 2.6](<https://devfeed.tech/articles/what-s-new-in-apollo-client-2-6-23582.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/whats-new-in-apollo-client-2-6>)

Author: Ben Newman

Published: 2019-06-11T22:01:40Z

Content type: release

Language: en

Sources: [Apollo Blog](<https://devfeed.tech/sources/apollo-blog.md>)

Topics: [apollo-client](<https://devfeed.tech/topics/apollo-client.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [React](<https://devfeed.tech/topics/react.md>)

Tags: [announcement](<https://devfeed.tech/tags/announcement.md>), [apollo-client](<https://devfeed.tech/tags/apollo-client.md>), [cache](<https://devfeed.tech/tags/cache.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [react](<https://devfeed.tech/tags/react.md>), [snapshots](<https://devfeed.tech/tags/snapshots.md>)

### AI overview

Apollo Client 2.6 is a backwards-compatible update that fixes bugs and adds options intended to improve component rendering performance. The article explains how immutable cache results, configurable cache normalization, cache eviction and garbage collection, async iterators, and smaller bundle sizes support the next major version's goals.

### Source excerpt

Apollo Client 2.6 is a backwards-compatible update that fixes bugs and provides new options (namely, , , and ) for rendering components faster and more smoothly. These changes lay the groundwork for the next major version of Apollo Client, whose interrelated goals and guiding principles we think you will find both compelling and worth understanding: - 🔏 Immutability of cache results, enabling equality where possible - 🔂 Selective, configurable cache normalization - ♻ Cache eviction,...

## Kotlin first impressions

DevFeed: [Kotlin first impressions](<https://devfeed.tech/articles/kotlin-first-impressions-27287.md>)

Original publisher: [Read original article](<https://blog.pchudzik.com/201711/kotlin-first-impressions/>)

Published: 2017-11-29T00:00:00Z

Content type: opinion

Language: en

Sources: [Paweł Chudzik](<https://devfeed.tech/sources/pawe-chudzik.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Development](<https://devfeed.tech/topics/development.md>), [Java](<https://devfeed.tech/topics/java.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [Hibernate](<https://devfeed.tech/topics/hibernate.md>)

Tags: [development](<https://devfeed.tech/tags/development.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [hibernate](<https://devfeed.tech/tags/hibernate.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [java](<https://devfeed.tech/tags/java.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>)

### AI overview

A developer shares first impressions from using Kotlin on an actively developed project. The article discusses Kotlin's default immutability, extension methods, interoperability with Java, integration with Spring and Hibernate, Gradle build scripts, named parameters, and compile-time null checks.

### Source excerpt

Recently while starting work on a project we've (team of two ;)) decided to try something new and use Kotlin. The project is far from ready and still under active development, but after writing some code in Kotlin I've got few observations I'd like to share. Read more

## Immutability in angular

DevFeed: [Immutability in angular](<https://devfeed.tech/articles/immutability-in-angular-27274.md>)

Original publisher: [Read original article](<https://blog.pchudzik.com/201707/immutability-in-angular/>)

Published: 2017-07-11T00:00:00Z

Content type: tutorial

Language: en

Sources: [Paweł Chudzik](<https://devfeed.tech/sources/pawe-chudzik.md>)

Topics: [Angular](<https://devfeed.tech/topics/angular.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Front end](<https://devfeed.tech/topics/frontend.md>), [Code](<https://devfeed.tech/topics/code.md>), [ui](<https://devfeed.tech/topics/ui.md>), [Graphs](<https://devfeed.tech/topics/graphs.md>)

Tags: [angular](<https://devfeed.tech/tags/angular.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [http](<https://devfeed.tech/tags/http.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

This article explains an immutable, Redux-inspired approach to managing complex hierarchical state in Angular. It recommends recalculating possible values from scratch after user changes, including when asynchronous backend requests and multiple UI components are involved, and presents a simpler categories-and-tags example.

### Source excerpt

Some time ago I've been struggling with mapping hierarchical data structure in angular. Labels hierarchy was complex (like 4 levels deep with multiple parents, multiple children, basically graph like structure with some logic behind it). In the end it was/is still working but that's the best I can say about it. Read more

## Immutable dto in jackson

DevFeed: [Immutable dto in jackson](<https://devfeed.tech/articles/immutable-dto-in-jackson-27268.md>)

Original publisher: [Read original article](<https://blog.pchudzik.com/201704/immutable-dto/>)

Published: 2017-04-15T00:00:00Z

Content type: tutorial

Language: en

Sources: [Paweł Chudzik](<https://devfeed.tech/sources/pawe-chudzik.md>)

Topics: [Jackson](<https://devfeed.tech/topics/jackson.md>), [JSON](<https://devfeed.tech/topics/json.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [constructor](<https://devfeed.tech/tags/constructor.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [jackson](<https://devfeed.tech/tags/jackson.md>), [json](<https://devfeed.tech/tags/json.md>)

### AI overview

This tutorial explains how Jackson 2.7 can deserialize immutable Java DTOs from JSON by using constructor-based object creation and @ConstructorProperties. It also describes using Lombok's @RequiredArgsConstructor to generate the required constructor metadata.

### Source excerpt

Immutability and functional programming are hot right now. But how to achieve immutability with objects deserialized from json? Luckily there is pretty old feature introduced in jackson 2.7.0 which uses constructor based object creation and uses @ConstructorProperties (introduced in java7). Read more

## Ethereum Dev Roundup: Q1

DevFeed: [Ethereum Dev Roundup: Q1](<https://devfeed.tech/articles/ethereum-dev-roundup-q1-16803.md>)

Original publisher: [Read original article](<https://blog.ethereum.org/en/2017/04/01/ethereum-dev-roundup-q1>)

Author: Vitalik Buterin

Published: 2017-04-01T02:55:28Z

Content type: opinion

Language: en

Sources: [Ethereum Foundation Blog](<https://devfeed.tech/sources/ethereum-foundation-blog.md>)

Topics: [Ethereum](<https://devfeed.tech/topics/ethereum.md>), [Development](<https://devfeed.tech/topics/development.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [zero-knowledge](<https://devfeed.tech/topics/zero-knowledge.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [attacks](<https://devfeed.tech/tags/attacks.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [dev](<https://devfeed.tech/tags/dev.md>), [ethereum](<https://devfeed.tech/tags/ethereum.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [metropolis](<https://devfeed.tech/tags/metropolis.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [proof-of-authority](<https://devfeed.tech/tags/proof-of-authority.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [research](<https://devfeed.tech/tags/research.md>), [research-development](<https://devfeed.tech/tags/research-development.md>), [state](<https://devfeed.tech/tags/state.md>), [verification](<https://devfeed.tech/tags/verification.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

An Ethereum development roundup discusses research progress in consensus algorithms, privacy, zero-knowledge proofs, and formal verification, alongside proposed changes involving proof of authority, transaction reversion, Metropolis, and protocol rules.

### Source excerpt

The last one and a half months have seen great progress for Ethereum research, and we are excited that the protocol is moving closer and closer to the point where it is ready for mainstream adoption. Progress on consensus algorithms, privacy, zero knowledge proofs and formal verification is happening at...

## Kotlin Data Classes Reduce Boilerplate Code

DevFeed: [Kotlin Data Classes Reduce Boilerplate Code](<https://devfeed.tech/articles/data-classes-in-kotlin-save-a-good-bunch-of-lines-of-code-kad-10-27155.md>)

Original publisher: [Read original article](<https://antonioleiva.com/data-classes-kotlin>)

Published: 2017-01-25T00:00:00Z

Content type: tutorial

Language: en

Sources: [Antonio Leiva](<https://devfeed.tech/sources/antonio-leiva.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>), [Code](<https://devfeed.tech/topics/code.md>), [Java](<https://devfeed.tech/topics/java.md>)

Tags: [class](<https://devfeed.tech/tags/class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [code](<https://devfeed.tech/tags/code.md>), [constructor](<https://devfeed.tech/tags/constructor.md>), [copy](<https://devfeed.tech/tags/copy.md>), [data-class](<https://devfeed.tech/tags/data-class.md>), [destructuring](<https://devfeed.tech/tags/destructuring.md>), [function](<https://devfeed.tech/tags/function.md>), [generate](<https://devfeed.tech/tags/generate.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [java](<https://devfeed.tech/tags/java.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [properties](<https://devfeed.tech/tags/properties.md>)

### AI overview

This tutorial explains Kotlin data classes, which represent state and automatically provide useful generated code. It covers destructuring, immutable-object copying, and how data classes reduce boilerplate compared with Java.

### Source excerpt

Everything Android, Kotlin and other random topics

## Reactive Apps with Model-View-Intent - Part 2: View and Intent

DevFeed: [Reactive Apps with Model-View-Intent - Part 2: View and Intent](<https://devfeed.tech/articles/reactive-apps-with-model-view-intent-part-2-view-and-intent-25455.md>)

Original publisher: [Read original article](<https://hannesdorfmann.com/android/mosby3-mvi-2/>)

Author: Hannes Dorfmann

Published: 2017-01-17T09:00:00Z

Content type: article

Language: en

Sources: [Hannes Dorfmann](<https://devfeed.tech/sources/hannes-dorfmann.md>)

Topics: [reactive](<https://devfeed.tech/topics/reactive.md>), [Development](<https://devfeed.tech/topics/development.md>), [Mobile](<https://devfeed.tech/topics/mobile.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [mvi](<https://devfeed.tech/tags/mvi.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

This second-part article introduces the Model-View-Intent pattern for building reactive Android applications. It explains how user intents produce model changes, how business logic returns a new immutable model, and how the view renders that model.

### Source excerpt

In the first part we have discussed what a Model actually is, the relation to State and how a well defined Model can solve some common issues in android development. In this blog post we continue our journey towards "Reactive Apps" by introducing the Model-View-Intent pattern to build Reactive Apps.

[Next page](<https://devfeed.tech/tags/immutability.md?cursor=WyIyMDE3LTAxLTE3VDA5OjAwOjAwKzAwOjAwIiwgImJkYTg1NTM2LTIzMWItNDZjNC1hOTQ2LTEwMjMxZGYyZjQzZSJd>)