← Back to context

Comment by pizlonator

1 day ago

They are not interchangeable. The semantics are observably different. Therefore, RC is not GC.

Reference counting gives you eager destruction. GC cannot.

GC gives lets you have garbage cycles. RC does not.

I think a part of the GC crew reclassified RC as GC to try to gain relevance with industry types during a time when GC was not used in serious software but RC was.

But this is brain damage. You can’t take a RC C++ codebase and replace the RC with GC and expect stuff to work. You can’t take a GC’d language impl and replace the GC with RC and expect it to work. Best you could do is use RC in addition to GC so you still keep the GC semantics.

7 comments

pizlonator

Reply
cryptonector  6 hours ago

> GC gives lets you have garbage cycles. RC does not.

This is the biggest difference, but if you disallow cycles then they come close. For example, the jq programming language disallows cycles, therefore you could implement it with RC or GC and there would be no observable difference except "eager destruction", but since you could schedule destruction to avoid long pauses when destroying large object piles, even that need not be a difference. But of course this is a trick: disallowing cycles is not a generic solution.

gf000  1 day ago

> Reference counting gives you eager destruction. GC cannot.

Tracing GC can't. Reference counting, which is by definition a GC can. It's like insects vs bugs.

And destructors are a specific language feature. No one says that they are a must have and if you don't have them then you can replace an RC with a tracing GC. Not that it matters, a ladybug is not the same as an ant, but they are both insects.

  • pizlonator  1 day ago

    The best part of these conversations is that if I say “garbage collection”, you have zero doubt that I am in fact referring to what you call “tracing garbage collection”.

    You are defining reference counting as being a kind of garbage collection, but you can’t point to why you are doing it.

    I can point to why that definition is misleading.

    Reference counting as most of the industry understands it is based on destructors. The semantics are:

    - References hold a +1 on the object they point to.

    - Objects that reach 0 are destructed.

    - Destruction deletes the references, which then causes them to deref the pointed at object.

    This is a deterministic semantics and folks who use RC rely on it.

    This is nothing like garbage collection, which just gives you an allocation function and promises you that you don’t have to worry about freeing.