Similar yet different. So confusing

There are concepts which are very similar, yet different and confuses many people.

Referential transparency vs immutability

Referential transparency is a concept in a programming language which guarantees that once the value is assigned to the variable it will not change there is no way to assign a different value to it. For example, in ES6 you can use const for it:

const a = { x: 1 };
a = { z: 1 }; // TypeError: Assignment to constant variable
a.x = 2; // This is ok

(Not sure why this is a type error, but you get the idea)

Immutability is a concept in a programming language (and in different areas) which guarantees that the value once it was created will remain unchanged. For example, in ES6 you can use Object.freeze for it:

let b = Object.freeze({ x: 1 });
b.x = 2; // Silently ignores error e.g. does nothing
b = { z: 1 }; // This is ok

Confusion: I guess not a lot of people know or use every day the terminology "referential transparency". Programming language calls it constant (const). And constant is something that stays unchanged, you can even say immutable...

Authentication vs authorization

Authentication in the context of a user accessing an application tells an application who the current user is and whether or not they're present (source).

Authentication answers the question - who you are.

Authorization in the context of a user accessing an application tells an application if the current user (including unauthenticated users) is allowed to make given action or not.

Authorization answers the question - what you allowed to do.

Confusion: for starters - names are very similar which wasn't the best idea in the first place (naming is hard). The second part of the confusion is that you typically need authentication to do authorization.

What are your favorite sources of confusion?

Photo by Lisa Algra on Unsplash

Comments

[Meghan (she/her)]

const a = { x: 1 };
a = { z: 1 }; // TypeError: Assignment to constant variable

this is a TypeError because by assigning a a new object value you are changing the prototype as well. Note: a = { x: 3 } wouldn't work either because while this new object's prototype has the same signature as the original value of a it is still a new prototype.

[stereobooster]

const a = { x: 1 }
a = { x: 1 } // TypeError: Assignment to constant variable.

I would say referential transparency is in different realm, this is not a type error in common case (though can seem like one in some cases).

It is in different realm the same way as borrow checker in Rust. Immutability is also in different realm, but can be modeled with types, for example with Readonly<T> in TypeScript or $ReadOnly<T> in Flow.

[Baptiste Prunot]

I might be wrong, but

const a = {x: 1}

is actually assigning a pointer to an object to a, so this:

const a = {x: 1};
a = {x: 2};

cannot work, because you are changing the value of a with a new pointer.

no problem with

a.x = 2

because you don't change the value of a: it's still the same pointer to the same object.

So to me it's correct to say const for immutability, because in your example it's not possible to change the real value of a (which is an address).

As I said, I might be wrong, but it's how I understand the concept and for now it hasn't failed me yet 😄

[stereobooster]

Referential transparency - means you can't reassign variable.

const a = { x:  1 };
const b = a;
a.x = 2;
a === b; //true, because it is the same reference

Immutability - means you can't mutate object.

let a = Object.freeze({x : 1})
a.x = 2;
a.x === 1; // true, because a is immutable

[Basti Ortiz]

The __proto__ and the prototype... Enough said.

[Sergiu Mureşan]

I always get the authentication and authorization terms wrong even when I know there is a difference between them.

Great article! Didn't know about Object.freeze