"

 Kickstart disks 

The current article states 'subsequent Amiga models all used ROM chips' [following the A1000] in relation to Kickstart.

However, I remember that the Amiga 3000 also required such a Kickstart disk. Can anyone confirm? Thanks!

Most A3000s used ROMs, but some (like mine) had a small ""Super Kickstart"" in ROM which read Kickstart from floppy or hard disk. (Super Kickstart was based on AmigaOS 1.4, which never appeared anywhere else.) IIRC, only the machines manufactured in Europe had ""Super Kickstart"", but I may well be wrong on that detail. I do know that I never got my machine to boot a v3.x AmigaOS =(. Cheers, (talk) 

 Freeing memory 

(This is relevant to a different Wikipedia article). I have the statement in front of me that, when a program terminates in AmigaOS, memory assigned by the program is not freed, and that it is therefore vital for the program to release all memory that it asked for, otherwise it is permanently ""leaked"". Is this the case?  

Memory that is not freed before termination of a program in the Amiga OS is leaked (assuming it was supposed to be freed - in some cases a program may have allocated structures and attached them to system objects, such as a device node).  One of the most common modes of testing on the Amiga was checking free memory after program exit; there were many tools that automated that.  Normal behavior of a program was to free all memory, and all malloc'd memory was automatically freed via exit-time hooks.  (I.e. leaking memory typically only happened to memory obtained via AllocMem() and the like.)   

Indeed. AmigaOS does little to no resource tracking in order to save the memory overhead that it costs to include tracking. There was also a third-party program that patched many allocate/free resource functions (e.g. AllocMem/FreeMem, OpenWindow/CloseWindow) and added resource tracking to them, however this would break any software that deliberately allocate memory then exited, for example programs which installed patches on system functions. Programs assume the responsibility for freeing all allocated memory. The standard C library implementation in most Amiga C compilers used an onexit handler that freed any memory allocated with the malloc() implementation, but if the program crashed or the AmigaOS memory allocation routines were called directly, memory allocations were not freed. Other languages had varying degrees of support for tracking memory, usually (like C) only if you used the language-specific memory allocators.  

Thank you for your replies. The reason for the question relates to a discussion I've been having on memory leak. I'm going to post a question which is very subjective, but maybe there's a consensus. The article includes ""In modern operating systems, normal memory used by an application is released when the application terminates"". Part of the debate is over whether this is really true, and whether it should say ""In some operating systems..."". The leading question is: is AmigaOS a ""modern operating system""? A supplementary dispute, where it says ""The application assumes that the request for memory has succeeded, and continues on this basis. This will typically result in an access violation but in some cases may result in damaging information belonging to this or (in primitive systems) some other application."" Should this have ""some systems"" in place of ""primitive systems""? Thanks in advance.  

The amiga would be included in ""modern operating systems"", and it does release ""normal memory"" (i.e. malloced) when the application ends.  Program crashes on an Amiga do not release memory, so you could say it leaks on process crash.  And a program that uses things like OpenFile() instead of open() will leak a filehandle (and some memory) if the program calls exit() without closing the file.  As for your second question, the answer would be ""some systems"" - many ""modern"" embedded systems (including running unix variants like uclinux) do not have memory protection, and can read (and possibly write) structures using NULL as a pointer without an access violation.  Personally, I HATE programs that don't check malloc (or any other calls) for failure.  Good programming practice on the Amiga (due to the lack of VM) was to test programs and the OS against random memory allocation failures to see if they recovered cleanly or not.  All allocations (and all system calls, etc) should be checked for failure and