[LRUG] The advantage of immutability?

[Roland Swingler]

> why an immutable object is an advantage

In general immutability is nice because a lot, lot less can go wrong with
immutable objects. A lot of bugs are caused by editing state incorrectly -
if you can't change the state of an object then a whole class of bugs
vanish by design.

In terms of your specific problem a way to approach it might be - you have
a Request of some form - instead of changing state model what is going on -
so create a Response model (almost certainly a better name - I don't know
your problem beyond what you've told us) with a state field of denied. To
deny a request, create a Response object set to denied.

This gives you some nice properties - you can start doing things like
recording like when the request was denied, who denied it etc. if you like;
also if a request is denied by mistake for then you can just create a new
Response and you have a history of all the state changes.

Now, none of this may be practical in your application (for example if lots
of other things are already coupled to a mutable state field on your
Request). In which case do whatever is simplest.

Thanks,
Roland

On Wed, Sep 9, 2015 at 11:25 AM, Jonathon Horsman <jonathon at arctickiwi.com>
wrote:

> Hey smart people
>
> Can you shed some light on why an immutable object is an advantage for a
> web-based Ruby app?
>
> For example this app I'm working on has these Request things and a user
> has the ability to deny a Request.
>
> So the user would click a button which performs a post to the Request
> controller's deny action.
> If I were using Rails or some non-immutable based system I would fetch the
> object from the database, set it's status to denied, and save it.
>
> However since this Request is an immutable object, I have to either:
>
> 1. Write an update_status method which sets that value in the database,
> which becomes tedious when there's lots of possible attribute update
> combinations
> or
> 2. Read the object from the database, copy all the values to a new object
> with the denied status, and stick that back into the database. Seems like
> pointless overhead and could be dangerous if later that object gets another
> attribute which I forget to copy.
>
> My knowledge of immutable objects originates with Java Strings which I
> understand makes sense for performance and memory management reasons.
> I don't think this applies here though?
>
> Thanks!
>
> Jonno
>
> _______________________________________________
> Chat mailing list
> Chat at lists.lrug.org
> Archives: http://lists.lrug.org/pipermail/chat-lrug.org
> Manage your subscription: http://lists.lrug.org/options.cgi/chat-lrug.org
> List info: http://lists.lrug.org/listinfo.cgi/chat-lrug.org
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.lrug.org/pipermail/chat-lrug.org/attachments/20150909/ad412e55/attachment-0003.html>