http://www.cocoabuilder.com/archive/xcode/322876-why-arc-ove...
http://daringfireball.net/linked/2011/09/19/the-unfamiliar
http://stackoverflow.com/questions/2484079/how-can-i-avoid-g...
Plus the underlying C part, didn't allow for more than a plain conservative GC.
ARC works by generating the retain/release calls the developers would write anyway with NeXTStep/Cocoa framework.
So while it is a good solution for Objective-C, it isn't because it thrumps GC, but rather due to Apple's failure with a stable GC.
However, that's not all of it. The iOS teams wouldn't touch the GC with a 10 foot pole, even had it worked, and with good reason. As the parent poster pointed out, GCs make performance and memory consumption unpredictable, especially on memory-constrained devices.
And yes, phones are memory-constrained, despite the 1/2 - 1GB of memory, because you are also managing some potentially very large assets (retina class images, ...). Especially without virtual memory, where having an unexpected spike in memory consumption can get you killed, having unpredictable memory consumption is a non-starter...and the pain you have to go through on Android to avoid GC problems is significant (for example real-time OCR via the video camera overlaid onto the video stream).
It's interesting that Android appears to be moving away from JIT to AOT with libart, I am very curious as to how that works out. My guess is that at least a subset of developers, those with stringent requirements, would also welcome more predictable memory management solution.
WP7 was full .NET with JIT.
WP8 is WinRT/.NET with AOT compilation.
Both seem to perform much better than Android and on par with iOS.
Although I do conceded that on WP8 there is a mix of reference counting(WinRT) and GC (.NET).
Google was supposed to present more information about ART at FOSDEM, but they canceled the presentation on the last minute. So still no information what they plan there, besides AOSP source code.
Xerox PARC systems already had GC enabled programming languages (Cedar/Lisp/Smalltalk) and they surely were less powerful than today's phones.
- Lisp OS
- Smalltalk OS
- Mesa/Cedar (a GC enabled systems programming)
Many a time I've seen people shrug off issues as "GC will handle it" in C# projects. Usually accompanied with the sound of many a developer crying whilst trying to work out what has gone wrong in production when 256Gb of RAM across several nodes disappears instantly. Memory ballooning, long GC pauses, reference leaks, swapping, VM over commitment are all waiting to hang you.
For non-gophers, a slice is roughly a bounds-checked Vector.
What you just described is how memory is allocated, but can this cause it to be retained outside a function body?
In Java, you code around it by doing
new String( line.substring( x, y);
String's constructor will copy the characters to a new buffer. I guess go will have something similar. Problem, of course, is that that means copying the objects. That can especially be an issue if the objects are mutable.An alternative in Java is to do
s = s.intern();
But that comes with its own problems. 'intern()' decreases memory usage, but is slow, and library writers cannot know whether it is a good idea to use it or not because they cannot know what is more important to the code calling the library: speed or memory.(1) Oracle is going to change/has changed this after measuring its impact. It turns out that the two extra fields that each string needs to keep track of what part of a buffer contains its characters more or less compensate for the decrease in memory usage that sharing strings brings.
Why? My understanding is that when you interned a string you were given something like a constant token to reference it. This did two things:
1. Equality was trivial. Instead of taking to strings and comparing each character, it could just see if the constants were equal. For strings you know you'll see often this could be great source of speedups. 2. You could end up saving a ton of memory. Let's say that string you're interning is 250 character long. Instead of taking up 250 unicode characters plus overhead, it's now... let's say... 8 bytes. Maybe you saved a few hundred bytes. Now multiply a few hundred bytes by a few fields times 10 million records in memory and that's nothing to sneeze at.
Interning is definitely optimization and not part of normal Java development.
Go's GC has its own caveats that you have to watch out for. It doesn't really save you from having to think about your object graph or architecture design.