16

I often hear the term "Stateless" and "Immutable". For example, HTTP is a stateless protocol, and a String object is an immutable object. But I have a hard time grasping the difference between the two. When I create a stateless object, it doesn't store any "state" data internally. And if I create an Immutable object, it mean its will never change.

Doesn't that mean the same thing?

Since the immutable object doesn't change, by definition it cannot have a state. It is what it is forever. And if an object doesn't have state, it cannot be mutated (by definition). Thus, aren't all stateless object immutable and immutable object stateless?

What could be an example of mutable stateless object or immutable stateful object?

Ramzi Khahil
  • 4,932
  • 4
  • 35
  • 69
Laurent Bourgault-Roy
  • 2,774
  • 1
  • 30
  • 36

4 Answers4

8

The context is important and there are two unrelated concepts here.

"HTTP is a stateless protocol" means that each request has no implicit knowledge of other requests, including any previous request sent by the same client. This is different from a protocol like FTP or SMTP where a connection is established and then different commands are sent - each command/request is "associated" to the same client/connection. Of course state/tracking is added back via. cookies and tracking URIs, and even pipelining - but the point is that each request is "new" and "separate" in the HTTP protocol.

"String is an immutable object" means that that particular object's data will always be identical to what it is now in every observable manner (this also implies that observable attributes can't be changed). Some purists might argue that it has deeper implications than this, but in practicality is is about observable attributes - the issue becomes more complicated when immutable objects can "contain" mutable objects.

(And yes, by technicality, an object with no allowed data - or state - can't be updated and is thus "immutable". However, once again, context is important and it's odd to talk about Fangs on an Elephant or a Trunk on a Tiger.)

Edit: Difference between the two

An object that has no state is stateless. All stateless objects are immutable (because there is nothing to mutate); this is a tautological technicallity. An object can have state and still be immutable - however, an object with state (immutable or otherwise) can no longer be considered stateless. As per comment on the linked answer: "[an immutable object] has exactly one state", the initial state.

— from my comment

Community
  • 1
  • 1
  • OK maybe HTTP was a poor choice of example. But in the context of object, I still hear the term "stateless object" http://stackoverflow.com/questions/9735601/what-is-stateless-object-in-java . Or maybe the guy really meant "immutable" in this context? – Laurent Bourgault-Roy Oct 19 '12 at 19:46
  • 4
    @LaurentBourgault-Roy An object that has no state is stateless. All stateless objects are immutable (because there is nothing to mutate); this is a tautological technicallity. An object can have state and still be immutable - however, an object with state (immutable or otherwise) can no longer be considered stateless. As per comment on the linked answer: "[an immutable object] has exactly one state", the initial state. –  Oct 19 '12 at 20:04
  • 1
    Ah, I see now. Would it be correct to say that Stateless objects are a subset of immutable objects, with the same interesting property (can be used safely in threaded code, guaranteed not to change in the future, etc), but with some additional properties of their own? (like a method called on any instance of the same class is garanteed to always return the same result, since their is no state to affect the outcome) – Laurent Bourgault-Roy Oct 19 '12 at 22:34
  • All that is stateless is immutable, but not vice-versa, so immutable is a superset of stateless, or... venning it up a bit `( immutable ( stateless ) ) ` – icc97 Jan 26 '17 at 20:27
6

No. They do not mean the same thing.

An Immutable Object can never change. That doesn't mean the data contained in that Object can't indicate State. It just means that if you want to represent a change in State, you need to create a new Object.

Stateless means that there is no state.

Justin Niessner
  • 242,243
  • 40
  • 408
  • 536
  • OK so these are really unrelated concept, and they don't affect one another. So a "stateless" class with no field, just method does not imply the same warranty a an "immutable" class where all field are readonly. Thank you! – Laurent Bourgault-Roy Oct 19 '12 at 19:38
  • Right. An immutable object can have state (store data), but that state will never change. A stateless object cannot store any data. I now understand what an immutable collection is! – Robert Mark Bram Jul 31 '13 at 13:25
  • 1
    How can an object have no state? Even if you instantiate the most basic object, it does have some state. The most simple object imaginable in Java, for instance, will have contain state. The reference to its class among other things. Is it even possible to obtain a truly stateless object in any language? – toniedzwiedz Jan 28 '16 at 09:24
  • @toniedzwiedz c++'s `class stateless {}` for one. In the Java case you can caveat it to "ignoring the JVM bookkeeping" – Caleth Jan 04 '17 at 12:30
3

I'd say it is the same thing in some contexts, but we focus on a slightly different aspects.

When people say that "stateless" means it has no state, it makes me laugh. Of course it has some state from some point of view, e.g. stateless service can be backed by complex graph of objects (dependency injection). The thing is network protocol has slightly different meaning of the "state": it is something that depends on previous request/response. But immutable service doesn't depend on previous calls too, by definition.

"Stateless" doesn't always related to HTTP-protocol, the same term we can use to argue setters in service objects in your shiny OOP code. And here you can see that these two terms are same in fact: immutable service is a stateless service and vice versa.

However, it's awkward for me to call a value object "stateless object". It sounds terrible.

Recap: in case of services (network or OOP, doesn't matter) I'd say these terms are interchangeable.

Just example:

interface Logger
{
    public function logWarning(string $message);
    public function logError(string $message);
}

It doesn't matter how many times we called logWarning or logError and order of calls doesn't matter too. Thus, we can call it "stateless service".

But this service is also has no setters and any mutators like changeFileName() -> it is an immutable service/object.

Mutability makes object stateful. Stateful makes object mutable. These terms are interdependent in context of services.

Misanthrope
  • 454
  • 4
  • 12
1

They are definitely not the same.

Immutable objects are the never changed. The state of immutable objects is never modified, aliasing immutable objects is harmless and no alias control is necessary for immutable objects, although alias control may be needed to prove that objects are in fact immutable.

And stateless means there is no state. HTTP is called a stateless protocol because each command is executed independently, without any knowledge of the commands that came before it. It is based on a request paradigm. In this protocol the communication generally takes place over a TCP/IP protocol.

Rahul Tripathi
  • 168,305
  • 31
  • 280
  • 331
  • What's interesting is that TCP maintain some state if I remember (you have to keep the connection to send your data). So that mean you can implement stateless protocol on top of stateful one? – Laurent Bourgault-Roy Oct 19 '12 at 19:51