Hacker News Reader

Comment by BoorishBears | Hacker News Reader

Android I've done for embedded apps, by using immutable data flows only, Optionals everywhere, and very careful debugging for memory leaks. Go to a screen, force gc, go back, force gc, memory before and after should be the same, we'd find leaks of as little as 4kb this way, and it was every bit as excruciating as it sounds.

It's weird using Swift and realizing how much of that trouble we went through is avoided just by not using a GC'd language

View on HN

I worked in Swift for just over a year. Love the language. But unfortunately you can still get reference cycles that leak memory. And they can be basically unsolvable with a large enough app. Merely avoiding GC doesn't fix all your problems!

Isn't reference counting just a different style of garbage collection? I see lots of articles saying that swift both is and isn't garbage collected, and I'm curious what the proper answer is here.

Yes, but the overhead is much smaller compared to other techniques, and it's simpler to predict runtime behavior because there is no nondeterminism when ignoring the runtime which would otherwise be introduced by collector behavior.

with all those differences, reference counting is not garbage collecting, it's like calling free in c garbage collecting, which is incorrect.

https://en.m.wikipedia.org/wiki/Garbage_collection_(computer...

Reference counting is listed as a strategy to achieve garbage collection. Broadly speaking, garbage collection is the process of automatically managing the lifecycles of objects in memory, which reference counting certainly achieves.

Not quite the same as garbage collection. When an object has a pointer null'ed, that object's reference count is reduced by 1. When the reference count reaches 0, that object is remove from memory. You could still cause memory leaks like so:

```

struct Node {

  var next: Node?

  var prev: Node?

}

var a = Node(next: nil, prev: nil)

let b = Node(next: nil, prev: a)

a.next = b

```

These two objects will persist in memory for the entire life of the app even when all reference to a and b are gone, except for their references to one another.

Reply on news.ycombinator.com