Mon premier blog

Garbage Collection: Algorithms for Automatic Dynamic Memory Management Rafael D Lins, Richard Jones
Publisher: Wiley

It's certainly traditional though; e.g. Another justification of the heap is that many algorithms are unable to perform their tasks without the need of a variable sized array or object, and thus require special allocations at run-time. As I discussed in my last post on Memory Allocation dynamic memory is hard to manage One of the duty of a GC system is to automate this process by tracking down (using various algorithms) such objects and reclaim the memory used by them automatically. (See: every implementation of garbage collection ever devised, including ARC.) This is where semantic attributes come in. But there is no need to I am not too familiar with the technical details of garbage collection, but I would like to express a few preliminary thoughts of a general nature about manual versus automatic memory management. Dynamic scoping style seems not to be a disadvantage when using the language, as long as you divide your code into context modules. Moving object fields to an object's or record's automatic destruction list would mean moving them to FinalizeRecord, and for the life of me, I cannot understand why FinalizeRecord exists at all. Garbage collection deals with the automatic management of dynamic memory. As I pointed out yesterday, with FastMM available, memory management is so much of a solved problem that it's a non-problem. Garbage Collection does exactly what it's more fancier name “Automatic dynamic memory management” suggests. This article discovers how memory management is more than tracking where your malloc() and free() are located. (read [13] for a mark-sweep algorithm) but it is probably not worth the effort using such a sophisticated algorithm if you are mixing in your program C++ code with other high level scripting language where garbage collection is implemented natively. If any of this was hard to understand (especially for lack of diagrams), I strongly recommend reading Garbage Collection: Algorithms for Automatic Dynamic Memory Management by Richard Jones and Rafael Lins. From a user's perspective, newLISP's memory management works just like garbage collection in other scripting languages: memory gets allocated automatically and unused memory gets recycled. I love Richter's "CLR via C#" book, and am looking for something similar that covers boxing, generics, class loading, garbage collection, etc. Garbage collection in Java is the processes of freeing the dynamic memory used by objects that are no longer being used by an application. This happens when distinct dynamic libraries are linked with the static library version of the CRT. The second is when the developer has partial control , with self-managing units of memory such as lists in LISP or pseudo-managed objects in Objective-C. Automatic reference counting and disposal of objects being proposed would make programming easier in some situations, and make ARC-enabled objects more compatible with interfaces and dynamic arrays. Oh, and since Greg mentioned "Inside the VM" (the free online chapters look fluffy to me, as Amazon feedback also states), if you were interested in that level I'd start with the classic book "Garbage Collection: Algorithms for Automatic Dynamic Memory Management" instead. NewLISP also does references passing by packaging variables into contexts.