← Back to context

Comment by OskarS

3 days ago

I would actually say it’s the opposite in this case: it’s extremely common in scripting languages for strings to be immutable, mutable strings are usually only available in lower level languages. I’m very surprised Ruby had this feature at all.

38 comments

OskarS

Reply
wavemode  3 days ago

Even in C, string literals are immutable, and mutating them is undefined behavior.

ttoinou  3 days ago

But in the syntax of scripting language its very easy to create a new string from the old string, destroy old string, replace variable by new string. Which appears mutable from the point of view of the developer

  • SomeoneOnTheWeb  3 days ago

    Can't you do the exact same in compiled languages e.g. C or Rust?

    • shikon7  2 days ago

      You can, but allocating and deallocating is more tedious without a GC, and if you care about performance, you might want to have mutable strings.

fiddlerwoaroof  3 days ago

Common Lisp and Smalltalk have mutable strings, I think. So it’s not too surprising that ruby does too, since it was pretty heavily influenced by these languages.

  • rurban  2 days ago

    Amongst the lisps, AutoLISP had the one standout feature that was immutable strings by default. Many other lisps wished they could have that too, esp. for the GC.

  • anonnon  2 days ago

    Specifically, it's non-literal strings that are mutable. Implementations of either may allow you to modify the literals, but it's likely to break something due to interning. The Common Lisp standard is clear that destructive literal modification is undefined behavior. I believe it's the same in Smalltalk, and I remember you were admonished to never use the direct modification messages (like at:put: or replaceFrom:to:with:) on strings without copying them first.

    • igouy  1 day ago 

          'justastring' at: 6 put: $S; yourself

    'justaString' .

      However

          #'justasymbol' at: 6 put: $S; yourself

    errorNoModification
        self error:  'symbols can not be modified.'

      2 replies →

    • fiddlerwoaroof  1 day ago

      I looked around and it seems like Smalltalk didn't make modifying literals UB, the way Common Lisp does but I'm not an expert. Still, for both languages, most implementations won't stop you if you modify string literals, you just have to deal with the consequences.

      1 reply →

superjan  3 days ago

It’s true that many languages have immutable strings, but for a web-focused scripting language it makes sense to default to mutable strings. I think the comment is about that you now need to choose mutable vs immutable, and that is framed as a consequence of broader adoption. Which is a development I have also seen before.

  • empthought  3 days ago

    > for a web-focused scripting language it makes sense to default to mutable strings

    Why do you say that? I would say the opposite.

    • superjan  3 days ago

      Because there’ll likely be a lot of string concatenation in a language whose job is to output HTML. Adding a single char to a 1k string will require allocating a modified copy, in mutable strings it’s just appending in a preallocated buffer.

      1 reply →

  • dragonwriter  1 day ago

    Ruby is a web-focused scripting language in the same sense that Python is an AI-focused scripting language.

    JavaScript is much more of a "web-focused scripting language" than Ruby is, and it is quite happy with immutable strings (only).

    > I think the comment is about that you now need to choose mutable vs immutable, and that is framed as a consequence of broader adoption.

    Ruby has also had immutable (frozen) strings for a very long time, so you've always had the choice. What is changing is that string literals are (eventually) going to migrate from "mutable with a strong-encouraged file level switch to make them immutable" to "immutable".

  • copirate  2 days ago

    > for a web-focused scripting language

    Ruby is not a web focused scripting language.

riffraff  2 days ago

Mutable strings were part of the perl heritage, which was one of the direct ancestors for ruby.