Simple reference counting is quite possibly the worst possible choice for automatic garbage collection, especially since it is so intuitively appealing. The common objection is that cycles are hard to handle; leading to either a broken behaviour (leaking garbage) or adding complicated cycle detection (negating the premise of a simple solution).<p>Apart from cycles, reference counting has several other issues. Some of my pet objections are:<p>* The need to add a mutable field to every object increases the active memory foot-print significantly (especially bad for caches).<p>* The frequent updates to that field must be done using atomic operations if the objects may be accessed by different threads (even though the objects themselves may be immutable).<p>* The updates to the reference field trashes the caches in a multi-core processor.<p>* The amount of work done managing these updates can easily become a significant part of the run-time of the program, in some cases dwarfing the actual work.<p>* Uncontrolled arbitrarily long pauses will happen when cascading deletions happen.<p>There are really cool and smart algorithms that make reference counting much better, but then the appeal of a simple natural algorithm for collecting garbage has come and gone.