net. alcoholics, compulsive gamblers, and drug addicts had successfully used the defense to defeat a wide variety of crimes. the model penal code : turning responsibility to the jury the american law institute - model penal code. in 1972, the american law institute, a panel of legal experts, developed a new rule for insanity as part of the model penal code. this rule says that a defendant is not responsible for criminal conduct where ( s ) he, as a result of mental disease or defect, did not possess " substantial capacity either to appreciate the criminality of his conduct or to conform his conduct to the requirements of the law. " this new rule was based on the district of columbia circuit ' s decision in the federal appellate case, united states v. brawner, 471 f. 2d 969 ( 1972 ). the federal rule : reagan gets into the act in 1984, congress passed, and president ronald reagan signed, the comprehensive crime control act. the federal insanity defense now requires the defendant to prove, by " clear and convincing evidence, " that " at the time of the commission of the acts constituting the offense, the defendant, as a result of a severe mental disease or defect, was unable to appreciate the nature and quality or the wrongfulness of his acts " ( 18 u. s. c. § 17 ). this is generally viewed as a return to the " knowing right from wrong " standard. the act also contained the insanity defense reform act of 1984, 18 u. s. c. § 4241, which sets out sentencing and other provisions for dealing with offenders who are or have been suffering from a mental disease or defect.


| allegro cl version 9. 0 | unrevised from 8. 2 to 9. 0. this document contains the following sections : 1. 0 garbage collection introduction lisp does its own memory management. the garbage collector is part of the memory management system. it disposes of objects that are no longer needed, freeing up the space that they occupied. while the garbage collector is working, no other work can be done. therefore, we have made the garbage collector as fast and unobtrusive as possible. allegro cl uses a version of the generation - scavenging method of garbage collection. because optimal performance of generation - scavenging garbage collection depends on the application, you have a great deal of control over how the garbage collector works. in this section, we will describe the user interface to the garbage collector, and suggest how to tune its performance for an application. in what follows, the generation - scavenging garbage collection system will be abbreviated gsgc, and the act of garbage collecting will be abbreviated gc. the allegro cl garbage collector is a two - space, generation - scavenging system. the two spaces are called newspace and oldspace. note that, as we describe below, newspace is divided into two pieces, called areas, and oldspace may be divided into a number of pieces, also called areas. generally, when we say newspace, we mean both newspace areas and when we say oldspace, we mean all oldspace areas. we try to use the word area when we want to refer to a single area, but please note that this naming convention is new and you may run into text that uses ` oldspace ' to refer to an oldspace area. usually, the context should make this clear. the two pieces of newspace are managed as a stop - and - copy garbage collector system. the two areas are the same size. at any one time, one area is active and the other is not. a newspace area is filled from one end to the other. imagine, for example, a book shelf. existing books are packed together on the right side. each new book is placed just to the left of the leftmost book. it may happen that books already placed are removed, leaving gaps, but these gaps are ignored, with each new book still being placed to the left of the location of the last new book. when the shelf fills up, the other shelf ( newspace area ) is used. first, all books remaining are moved to the other shelf, packed


, with each new book still being placed to the left of the location of the last new book. when the shelf fills up, the other shelf ( newspace area ) is used. first, all books remaining are moved to the other shelf, packed tight to one side, and new books are placed in the next free location. so with lisp objects in newspace areas. all existing objects are packed together on one side of the area and new objects are placed in the free space next to the existing objects, with gaps left by objects which are no longer alive being ignored. when the area fills up, lisp stops and copies all live objects to the other area, packing them tight. then the process is repeated. the process of copying objects from one newspace area to the other is called a scavenge. we will discuss the speed of scavenges below, but scavenges are supposed to be so fast that humans usually barely notice them. a scavenge happens in one of the following cases : : allocation : lispstatic - reclaimable, for example, see cl : make - array in implementation. htm ), or a weak - vector or finalization will cause aclmalloc space to be freed ( see section 10. 0 weak vectors, finalizations, static arrays, etc. ). the first listed cause is under user - control. the second and third causes are under system control and the resulting scavenge cannot be prevented if the system determines it must occur. the system keeps track of the age of objects in newspace by counting the number of scavenges that the object has survived. the number of scavenges survived is called the generation of an object. when objects are created, they have generation 1, and the generation is increased by 1 at each scavenge. of course, many objects become garbage as time passes. ( an object is garbage when there are no pointers to it from any other live object. if there are no pointers to an object, nothing can reference or access it and so it is guaranteed never to be looked at again. thus, it is garbage. ) the theory of a generation scavenging garbage collector is that most objects that will ever become garbage will do so relatively quickly and so will not survive many scavenges. the problem with a stop - and - copy system is that objects that survive have to be moved and moving objects takes time. if an object is going to be around for a while ( or for the


so will not survive many scavenges. the problem with a stop - and - copy system is that objects that survive have to be moved and moving objects takes time. if an object is going to be around for a while ( or for the entire lisp session ), it should be moved out of newspace to some place where it does not have to be moved ( or is moved much less often ). this is where the other half of the generation scavenging algorithm comes into play. once an object has survived enough scavenges, it is assumed to be long - lived and is moved to oldspace. oldspace is not touched during scavenges and so objects in oldspace are not moved during scavenges, thus saving considerable time over a pure stop - and - copy system. part of a scavenge is checking the age ( generation ) of surviving objects and moving those that are old enough to oldspace. the remaining objects are moved to the other newspace area. the age at which objects are tenured is user - settable. its initial value is 4 and that seems to work for many applications. we will discuss below how changing that ( and many other ) settings can affect gc performance. the process of moving an object to oldspace is called tenuring and the object moved is said to be tenured. at one point, oldspace was also called tenured space and you may see that term occasionally in allegro cl documents. note the assumption : objects that survive a while are likely to survive a long while. if one could know exactly how long an object is going to survive, one could provide the best possible garbage collection scheme. but that knowledge is not available. objects are created all the time by different actions and users and even application writers typically do not know what actions create objects or how long those objects will live. indeed, that information often depends on future events that are hard to control - - such as the behavior of the person running the application. so the algorithm makes that assumption : if an object survives for a while, it is likely to survive for a long while, perhaps forever ( forever means the length of the lisp session ). of course, for many objects this assumption is wrong : the object may become garbage soon after it is tenured. however, as we said above, scavenges ( which are automatic and cannot be prevented by a user although they can be triggered by a user ) do not touch oldspace. in order to clear garbage from olds


after it is tenured. however, as we said above, scavenges ( which are automatic and cannot be prevented by a user although they can be triggered by a user ) do not touch oldspace. in order to clear garbage from oldspace, a global garbage collection ( global gc ) must be done. an interface for automating global gc ' s is provided in allegro cl and different interfaces are easy to implement ( see below for more information ), but the two important points about global gc ' s are : the lisp heap grows upwards ( to higher addresses ). oldspaces are at low addresses and newspace occupies addresses higher than any oldspace area. this means that newspace can grow without affecting oldspace and oldspace can grow ( usually by creating a new oldspace area ) by having newspace move up as far as necessary. why might newspace grow? suppose, for example, a newspace area is 600 kbytes and you want to allocate a 1 mbyte array. newspace has to grow to accommodate this. why might oldspace grow? as objects are tenured to oldspace, it slowly fills up. even with regular global gc ' s, it can fill up. when it does, newspace moves up and a new old area is created. ( new areas are created rather than a single area being expanded for various technical reasons. we discuss below how to reduce sizes dynamically. see section 3. 5 can other things be changed while running?. ) we will not describe the internal algorithms of the garbage collector because they cannot be changed or modified by users in any way. but let us consider how newspace might be moved, as this might make the process clearer. suppose the current scavenge is about to move live objects to the high address area. before anything is moved, lisp can compute how much space the live objects need, how much space objects waiting to be allocated need, and how much space a new old area needs. from that information, it can compute the highest address of the high address newspace area. it requests from the operating system that the area be allocated ( using malloc or sbrk ), and once the operating system confirms the allocation, starts copying the live objects to that high address, filling toward lower addresses. when all live objects have been moved and new objects are allocated in the high address newspace area, the new oldspace area ( if one is required ) can be created and the location of the low address


that high address, filling toward lower addresses. when all live objects have been moved and new objects are allocated in the high address newspace area, the new oldspace area ( if one is required ) can be created and the location of the low address newspace area can be determined. recall that high address newspace area is active so the low address newspace area does not contain anything of importance. a consequence of what we just said about newspace moving when it has to grow or when a new oldspace area is needed is that the size of the lisp image can grow while it is running. this is usually normal, indeed what you want. it allows images to start small and grow as much ( but no more ) than they need. it also allows the same image to run effectively on machines with different configurations. but, sometimes growth can be unexpected and the image can want to grow to a size larger than the operating system can handle ( usually because there is not enough swap space ). the growth is often necessary, because of the type of application being run. what is important is that the growth be managed and be no more than is really needed. in earlier releases, space for foreign code loaded into the image, space for foreign objects, and direct calls to malloc all could cause a gap to be placed above newspace. if a new oldspace or a larger newspace was needed, it had to be placed above the gap, causing in some cases a small need for additional space to result in a multimegabyte increase in image size. now, malloc space is placed away from the new and old spaces and so the lisp heap ( new and old spaces together ) are unaffected and can grow incrementally as needed. there is a lisp heap size specified by the lisp - heap - size argument to build - lisp - image ( see building - images. htm ). the os will try to reserve this space when lisp starts up. if more space is needed, lisp will request it from the os but it is possible more space will not be available. if this happens, you might increase the original request. the space reserved in a running lisp is reported as ' resrve ' on the ' lisp heap ' line of the output of ( room t ). if the heap grows larger than that size, gaps may appear. if you see gaps in your application, you should consider starting with an image with a larger heap size. application writers and users can control the


of the output of ( room t ). if the heap grows larger than that size, gaps may appear. if you see gaps in your application, you should consider starting with an image with a larger heap size. application writers and users can control the behavior of the garbage collector in order to make their programs run more efficiently. this is not always easy, since getting optimal behavior depends on knowing how your application behaves and that information may be difficult to determine. also, there are various paths to improvement, some of which work better than others ( but different paths work better for different applications ). one thing to remember is that ( unless the image needs to grow larger than available swap space ), things will work whether or not they work optimally. you cannot expect optimal gc behavior at the beginning of the development process. instead, as you gather information about your application and gc behavior, you determine ways to make it work better. the automated gc system is controlled by switches and parameters ( they are listed in section 5. 0 system parameters and switches below ). there is not much difference between a switch and a parameter ( a switch is usually true or false, a parameter usually has a value ) and there probably should not be a distinction, but these things are hard to change after they are implemented. the functions gsgc - switch and gsgc - parameter can be used to poll the current value and ( with setf ) to set the value of switches and parameters. the function gsgc - parameters prints out the values of all switches and parameters : cl - user ( 14 ) : ( sys : gsgc - parameters ) : generation - spread 4 : current - generation 4 : tenure - limit 0 : free - bytes - new - other 131072 : free - percent - new 25 : free - bytes - new - pages 131072 : expansion - free - percent - new 35 : expansion - free - percent - old 35 : quantum 32 ( switch : auto - step ) t ( switch : use - remap ) t ( switch : hook - after - gc ) t ( switch : clip - new ) nil ( switch : gc - old - before - expand ) nil ( switch : next - gc - is - global ) nil ( switch : print ) t ( switch : stats ) t ( switch : verbose ) nil ( switch : dump - on - error ) nil cl - user ( 15 ) : gsgc - switch can poll and set switches while gsgc


( switch : print ) t ( switch : stats ) t ( switch : verbose ) nil ( switch : dump - on - error ) nil cl - user ( 15 ) : gsgc - switch can poll and set switches while gsgc - parameter can poll and set parameters : here we poll and set the cl - user ( 15 ) : ( setf ( sys : gsgc - switch : print ) nil ) nil cl - user ( 16 ) : ( sys : gsgc - switch : print ) nil cl - user ( 17 ) : ( setf ( sys : gsgc - switch : print ) t ) t cl - user ( 18 ) : ( sys : gsgc - switch : print ) t cl - user ( 19 ) : the gc function can be used to toggle some of the switches. the system will cause a scavenge whenever it determines that one is necessary. there is no way to stop scavenges from occurring at all or even to stop them from occurring for a specified period of time. however, you can cause a scavenge by calling the gc function with no arguments : ( excl : gc ) ; ; triggers a scavenge you can also cause a scavenge and have all live objects tenured by calling the gc function with : tenure, like this global gc ' s ( a gc of old and new space ) are not triggered automatically ( but triggering can be automated ). you can trigger a global gc by calling gc with the argument t : ( excl : gc t ) ; ; triggers a global gc see section section 6. 0 global garbage collection for information on other ways to trigger a global gc and ways to automate global gc ' s. the function room provides information on current usage ( it identifies oldspaces and newspace and free and used space in each ). setting the : verbose switches causes the system to print information while gc ' s are occurring. see section 5. 4 gsgc switches and section 3. 1 how do i find out when scavenges happen?. ( room t ) provides the most information about the current state of memory management. here is a ( room t ) output from a allegro cl image that has been doing a fair amount of work. this is from a unix machine and was done immediately after a global gc, so some of the oldspaces have significant free space. cl - user ( 1


) output from a allegro cl image that has been doing a fair amount of work. this is from a unix machine and was done immediately after a global gc, so some of the oldspaces have significant free space. cl - user ( 1 ) : ( room t ) area area address ( bytes ) cons other bytes # type 8 bytes each ( free : used ) ( free : used ) top # x106a0000 new # x10598000 ( 1081344 ) 134 : 13113 340128 : 582984 new # x10490000 ( 1081344 ) - - - - - - - - - - 1 old # x10290000 ( 2097152 ) 0 : 0 2095952 : 0 0 * old # x10000e80 ( 2683264 ) 0 : 68273 0 : 2124792 tot ( old areas ) 0 : 68273 2095952 : 2124792 * = closed old area root pages : 61 lisp heap : # x10000000 pos : # x106a0000 resrve : # x10fa0000 aclmalloc heap : # x64000000 pos : # x64011000 resrve : # x640fa000 pure space : # x2d1aa000 end : # x2d747ff8 code type items bytes 112 : ( simple - array t ) 6586 930920 28. 3 % 1 : cons 80502 644016 19. 6 % 8 : function 8432 520192 15. 8 % 7 : symbol 17272 414528 12. 6 % 117 : ( simple - array character ) 2259 259984 7. 9 % 96 : ( short - simple - array t ) 17498 151736 4. 6 % 18 : bignum 2966 139928 4. 3 % 125 : ( simple - array ( unsigned - byte 8 ) ) 31 87816 2. 7 % 12 : standard - instance 3291 52656 1. 6 % 9 : closure 2301 39688 1. 2 % 15 : structure 666 24944 0. 8 % 127 : ( simple - array ( unsigned - byte 32 ) ) 9 9920 0. 3 % 108 : ( short - simple - array code ) 16 7368 0. 2 % 10 : hash - table 108 3456 0. 1 % 17


: ( simple - array ( unsigned - byte 32 ) ) 9 9920 0. 3 % 108 : ( short - simple - array code ) 16 7368 0. 2 % 10 : hash - table 108 3456 0. 1 % 17 : double - float 120 1920 0. 1 % 111 : ( short - simple - array foreign ) 51 1216 0. 0 % 16 : single - float 141 1128 0. 0 % 118 : ( simple - array bit ) 11 296 0. 0 % 20 : complex 11 176 0. 0 % 80 : ( array t ) 7 168 0. 0 % 11 : readtable 8 128 0. 0 % 123 : ( simple - array ( signed - byte 32 ) ) 1 88 0. 0 % 13 : sysvector 3 48 0. 0 % 85 : ( array character ) 1 24 0. 0 % total bytes = 3292344 aclmalloc arena : max size free bytes used bytes total 112 3472 112 3584 496 3472 496 3968 1008 2016 2016 4032 2032 0 12192 12192 4080 0 8160 8160 9200 18400 18400 36800 total bytes : 27360 41376 68736 cl - user ( 2 ) : newspace is divided into two equal size parts ( only one of which is used at any time ). there can be numerous oldspaces : two are shown in the example, but many more are common after lisp has run for a while. oldpsaces are numbered. the gsgc - parameter : open - old - area - fence takes such a number as an section 5. 1 parameters that control generations and tenuring for information on gsgc - parameters ). the 0th old area in the output is closed, as indicated by the asterisk. if there are no closed old areas : open - old - area - fence ) returns 0 ) then no asterisks show up and the " * = closed old area " note isn ' t given. when asterisks are shown, they denote any old areas that are closed. see the discussion of : open - old - area - fence in section 5. 1 parameters that control generations and tenuring and also the note on closed old areas after the table for information on closed and open old areas. root pages : 61 root pages contain information about pointers from oldspace to newspace. lisp heap : # x10000000 pos :


also the note on closed old areas after the table for information on closed and open old areas. root pages : 61 root pages contain information about pointers from oldspace to newspace. lisp heap : # x10000000 pos : # x106a0000 resrve : # x10fa0000 aclmalloc heap : # x64000000 pos : # x64011000 resrve : # x640fa000 pure space : # x2d1aa000 end : # x2d747ff8 the first value is the starting address of the specified heap in memory. the ` pure space ' line only appears in lisps which use a pll file ( see pll - file ), showing where the pll files is mapped. in the first two lines, pos ( position ) is the highest - use location ; this is one byte larger than the highest memory used by the lisp. some operating systems will only commit ( assign physical pages ) to memory between base ( inclusive ) and position ( exclusive ). this is a hexadecimal address value. resrve ( reserved ) is the number of bytes lisp thinks is reserved to it in virtual memory space. on some operating systems which support it, addresses greater than position, but less than starting location + reserved, will not be overwritten by shared - libraries, other memory mapping operations, etc. the lisp heap reserved size is a true limit only for certain free products. with paid license images ( and some free products ), this value is important only because if the heap grows larger than this limit, gaps in the heap may appear. see section 1. 8 the almost former gap problem for more information. this value is not a limit in any sense on how big the image can grow. the aclmalloc heap was called the " c heap " in earlier releases but its name was changed to reflect its real nature. it is the aclmalloc area used for space allocated by the aclmalloc function. that function differs from malloc ( ) in that it ensures that lisp will remember the location of aclmalloc ' ed allocations and preserve it through dumplisp and restarts, thus guaranteeing that aclmalloc addresses remain valid. more information on aclmalloc and regular malloc ( ) : malloc ( ) space is always started fresh when a lisp starts up, so addresses used by malloc


% 80 : ( array t ) 7 168 0. 0 % 11 : readtable 8 128 0. 0 % 123 : ( simple - array ( signed - byte 32 ) ) 1 88 0. 0 % 13 : sysvector 3 48 0. 0 % 85 : ( array character ) 1 24 0. 0 % total bytes = 3292344 the aclmalloc arena describes allocation of space for aclmallocs and foreign data. it is divided into chunks of various sizes to allow allocation of requests of various sizes without fragmentation. ( space allocated by aclmalloc is freed by aclfree. ) aclmalloc arena : max size free bytes used bytes total 112 3472 112 3584 496 3472 496 3968 1008 2016 2016 4032 2032 0 12192 12192 4080 0 8160 8160 9200 18400 18400 36800 total bytes : 27360 41376 68736 as a user, or as an application writer, how can you get the garbage collector to work best for you? at first, you do not have to do anything. the system is set up to work as delivered. you will not run out of space, global gc ' s will happen from time to time ( as described below, see section 6. 0 global garbage collection ), the image will grow as necessary, and assuming you do not run out of swap space, everything will work. of course, it will not necessarily work as well as it could. as delivered, the garbage collector is set to work best with what we assume is a typical application : objects, none of which are too big, are created as needed. most objects that survive a while are likely to survive a long while or perhaps forever, and so on. if your application ' s use of lisp has different behavior, performance may be suboptimal. so what to do? one problem is that optimizing gc behavior is a multidimensional problem. factors that affect it include optimization in a multidimensional environment is always complicated. the first step is always to gather the information necessary to do the tuning. information like : section 3. 1 how do i find out when scavenges happen? section 3. 2 how many bytes are being tenured? section 3. 3 when there is a global gc, how many bytes are freed up? section 3. 4 how many old areas are there after your application is loaded? section 3


? section 3. 2 how many bytes are being tenured? section 3. 3 when there is a global gc, how many bytes are freed up? section 3. 4 how many old areas are there after your application is loaded? section 3. 5 can other things be changed while running? there are three gsgc switches ( these control the behavior of the garbage collector ) that affect printing information about the garbage ( setf ( sys : gsgc - switch : print ) t ) will cause a short message to be printed whenever a scavenge happens. unless the t, no message will be printed. switches control the amount of information printed. if the : stats switch is true, the message contains more information but the information is compact. if the : verbose switch is also true, a longer, more easily understood message is printed. ; ; in this example, we cause a scavenge with all flags off, ; ; then with : print true, then : print and : stats true, ; ; and finally : print, : stats, and : verbose all true. cl - user ( 5 ) : ( gc ) cl - user ( 6 ) : ( setf ( sys : gsgc - switch : print ) t ) t cl - user ( 7 ) : ( gc ) gc : done cl - user ( 8 ) : ( setf ( sys : gsgc - switch : stats ) t ) t cl - user ( 9 ) : ( gc ) gc : e = 17 % n = 17536 t + = 0 a - = 0 cl - user ( 10 ) : ( setf ( sys : gsgc - switch : verbose ) t ) t cl - user ( 11 ) : ( gc ) scavenging... done eff : 15 %, copy new : 1664 + tenure : 16064 = 17728 page faults : gc = 0 major + 2 minor cl - user ( 12 ) : : stats true, the message contains much more information, but it is coded - - e means efficiency, n means bytes copied in newspace, t means bytes copied to oldspace ( i. e. bytes : verbose also true, the same information is displayed in expanded form and additional information ( about page faults ) is provided. efficiency is defined as the ratio of cpu time not associated with gc to total cpu time. efficiency should typically be 75 % or higher, but the efficiencies in the example are low because we


information ( about page faults ) is provided. efficiency is defined as the ratio of cpu time not associated with gc to total cpu time. efficiency should typically be 75 % or higher, but the efficiencies in the example are low because we triggered gc ' s without doing anything else of significance. it is usually desirable to have : stats true while developing software. this allows you to monitor gc behavior and see if there seems to be a problem. that information is shown when the : stats switches are true, but perhaps the real question is whether things are being tenured that would be better left in newspace ( because they will soon become garbage ). this often happens when a complex operation ( like a compile of a large file ) is being carried out. this question, in combination with the next can tell you if that is the case. in the following, copied from above, 0 bytes are tenured in the first gc ( t + = 0 ) and 16064 in the second ( tenure : 16064 ) : cl - user ( 9 ) : ( gc ) gc : e = 17 % n = 17536 t + = 0 a - = 0 cl - user ( 10 ) : ( setf ( sys : gsgc - switch : verbose ) t ) t cl - user ( 11 ) : ( gc ) scavenging... done eff : 15 %, copy new : 1664 + tenure : 16064 + aclmalloc free : 0 = 17728 page faults : gc = 0 major + 2 minor cl - user ( 12 ) : switches are true, the amount of space freed by a global gc is printed at the end of the report. here is an example. the form t ) triggers a global gc. cl - user ( 13 ) : ( gc t ) gc : mark pass... done ( 1, 583 + 66 ), marked 128817 objects, max depth = 17, cut 0 xfers. weak - vector pass... done ( 0 + 0 ). cons - cell swap... done ( 0 + 67 ), 346 cons cells moved symbol - cell swap... done ( 17 + 0 ), 1 symbol cells moved oldarea break chain... done ( 83 + 0 ), 40 holes totaling 6816 bytes page - compaction data... done ( 0 + 0 ). address adjustment... done ( 1, 400 + 67


cells moved oldarea break chain... done ( 83 + 0 ), 40 holes totaling 6816 bytes page - compaction data... done ( 0 + 0 ). address adjustment... done ( 1, 400 + 67 ). compacting other objects... done ( 150 + 0 ). page compaction... done ( 0 + 0 ), 0 pages moved new rootset... done ( 667 + 0 ), 20 rootset entries building new pagemap... done ( 83 + 0 ). merging empty oldspaces... done, 0 oldspaces merged. global gc recovered 9672 bytes of old space. gc : e = 0 % n = 1504 t + = 0 a - = 0 pfg = 54 + 187 cl - user ( 14 ) : the next to last line reports on what was recovered from oldspace ( 9672 bytes ). the value is often much higher. it is low in this example because we have not in fact done anything significant other than test gc operations. there is plenty of other information but we will not describe its meaning in detail. it is typically useful in helping us help you work out complicated gc problems. the amount of space freed is a rough measure of how many objects are being tenured that perhaps should be left for a while longer in newspace. if the number is high, perhaps things are being tenured too quickly ( increasing the value of the switch will keep objects in newspace longer, as will a larger the output printed by room shows the two newspace areas and the various oldspace areas. here is an example of room output. ( room takes an argument to indicate how much information should be displayed ). the following is the output of ( cl : room t ), which causes the most information to be displayed. cl - user ( 3 ) : ( room t ) area area address ( bytes ) cons other bytes # type 8 bytes each ( free : used ) ( free : used ) top # x569a000 new # x5134000 ( 5660672 ) 5 : 95781 597040 : 4239616 new # x4bce000 ( 5660672 ) - - - - - - - - - - 7 old # x498e000 ( 2359296 ) 458 : 18903 31904 : 2170416 6 old # x


9 % 98 : ( simple - array ( unsigned - byte 8 ) ) 44 105184 0. 6 % 97 : ( simple - array bit ) 49 103952 0. 6 % 15 : structure 830 33144 0. 2 % 100 : ( simple - array ( unsigned - byte 32 ) ) 12 10264 0. 1 % 10 : hash - table 225 7200 0. 0 % 18 : bignum 410 4480 0. 0 % 16 : single - float 505 4040 0. 0 % 111 : ( simple - array foreign ) 103 2464 0. 0 % 17 : double - float 124 1984 0. 0 % 64 : ( array t ) 22 528 0. 0 % 65 : ( array bit ) 13 312 0. 0 % 13 : sysvector 14 224 0. 0 % 20 : complex 12 192 0. 0 % 11 : readtable 7 112 0. 0 % 69 : ( array character ) 1 24 0. 0 % total bytes = 16939984 aclmalloc arena : max size free bytes used bytes total 48 3024 48 3072 496 3968 0 3968 1008 4032 0 4032 2032 2032 2032 4064 4080 8160 36720 44880 5104 10208 10208 20416 9200 27600 9200 36800 20464 20464 20464 40928 total bytes : 79488 78672 158160 cl - user ( 4 ) : the output shows the two equal size newspace areas, only one of which is being used. it also shows eight oldspaces and provides information about what is in the oldspaces. then information is printed about other objects such as the number of root pages ( a root page keeps information on pointers from oldspace to newspace - - these pointers must be updated after a scavenge ), and the locations of the lisp and c heaps. then, there is a table showing the types and numbers of objects. finally, used and available malloc space is displayed. yes. the function resize - areas can be used to rearrange things while running. it is typically useful to call this function, for example, after loading a large application. if you know desirable old - and newspace sizes for your application, it is preferable to build an image with those sizes ( using the : oldspace and : newspace arguments to build - lisp - image, see building - images


application. if you know desirable old - and newspace sizes for your application, it is preferable to build an image with those sizes ( using the : oldspace and : newspace arguments to build - lisp - image, see building - images. htm for more information ). however, you may not know until runtime what the best sizes are, in which case you can call resize - areas on application startup. be warned that it may take some time. another use of resize - areas is when you wish to dump an image ( with dumplisp ) into which your application has been loaded. you call resize - areas just before dumplisp in that case. the initial sizes of newspace and oldspace are determined when the image is built with build - lisp - image. see building - images. htm ( where build - lisp - image is fully documented - - the page on it is brief to avoid two sources for the same complex discussion ) the : newspace argument to build - lisp - image controls the initial size of newspace and the : oldspace argument the initial size of oldspace. an image dumped with dumplisp inherits new and oldspace sizes from the dumping image. see dumplisp. htm. resize - areas will restructure old and newspace sizes in a running image. the garbage collector will automatically resize old and newspace when it needs to. the amount of resizing depends on space required to allocate or move to oldspace live objects, and also on the parameters that relate to sizes. the parameters and switches described under the next set of headings control the action of the garbage collector. you may change them during run time to optimize the performance of the lisp process. all parameters and switches values may be set with setf. however, some values should not be changed by you. the descriptions of the parameters say whether you should change their values. by default, the system does automatically increase the generation number. you may find that it is useful to step it yourself at appropriate times with a call to gsgc - step - generation. there is really no difference between a parameter and a switch other than the value of switches is typically nil while parameters often have numeric values. however, once both were implemented, it became difficult to redo the design. the function gsgc - parameters prints the values of all parameters and switches. gsgc - switch and gsgc - parameter retrieve the value of, respectively,


- negative integer which is the number of the oldest old area that is open ( not closed ). old areas are numbered with 0 as the oldest old area. this parameter is setfable, either with the number of the old - area that is desired to be the first open - old - area, or with a negative number, for which the old - areas are counted backward to set the fence. for example, see the note on closed old areas just after this table for more information. old areas can be marked as closed. when an old area is closed, no objects are newly tenured into a closed old - area ; it is as if the area is full. also, no dead object in a closed old area is collected while the area is closed, and data pointed to by that object is also not collected. see the description of the the table just above for details on how to specify old areas as the intended usage model for closing old areas is this : a programmer with an application, such as a var, will load up their application, perform a global - gc and possibly a resize - areas, and then close most of the old - areas, leaving room for their users ' data models to be loaded into the open - areas. when the user is done with the data model, it can be thrown away and a fast global - gc performed, making way for the next data model. the following parameters control the minimum size of newspace and when the system will allocate a new newspace. at the end of a scavenge, at : free - bytes - new - other bytes must be free, and at : free - percent - new percent of newspace must be free. if these conditions are not met, the system will allocate a new newspace, large enough for these conditions to be true after allocating the object that caused the scavenge, if there is one. ( unless explicitly called by the user, a scavenge occurs when the system is unable to allocate a new object. ) note that there is no system reason why there are two parameters, : free - bytes - new - other - - differences were anticipated in the original specification but none was never implemented. the two parameter values are added to get total free | | the value of this parameter is a 32 - bit integer which represents the minimum amount of space ( in 8 kbyte pages ) that will be requested for a new new or old space and the granularity of space requested ( that is


free | | the value of this parameter is a 32 - bit integer which represents the minimum amount of space ( in 8 kbyte pages ) that will be requested for a new new or old space and the granularity of space requested ( that is space will be requested in multiples of : quantum pages ). its initial value is 32. this parameter value is overshadowed by the other size - related parameters described immediately below, and for that reason, we do not recommend that you change this value. | | | this is one of the parameters which determine the minimum free space which must be available after a scavenge. its initial value is 131072. | | | this is one of the parameters which determine the minimum free space which must be available after a scavenge. its initial value is 131072. | | | this parameter specifies the minimum fraction of newspace which must be available after a scavenge, or else new newspace will be allocated. its initial value is 25. | the final two parameters control how large new newspace ( and new oldspace ) will be. if newspace is expanded or a new oldspace is allocated, then at least the percentage specified by the appropriate parameter shall be free, after, in the case of newspace, the object that caused the scavenge has been allocated, and after, in the case of oldspace, all objects due for tenuring have been allocated. there are different concerns for the newspace parameter and the oldspace parameter. let us consider the oldspace parameter first. in the case where no foreign code is loaded, then oldspaces are carved out of newspace, and newspace grows up into memory as needed. if each new oldspace is just large enough, the next time an object is tenured, another oldspace, again just large enough, will be created, and the result will be a bunch of small oldspaces, rather than a few larger ones. this problem will not occur if there is foreign code, since some oldspaces will be as large as previous newspaces. if the function room shows a bunch of little oldspaces, you might try increasing the : expansion - free - percent - old parameter to cure the problem. however, resize - areas can be used instead to coalesce the oldspaces into one. the newspace parameter is more complicated, since newspace can grow incrementally ( assuming growth is not blocked by foreign code ). since growing newspace takes


- areas can be used instead to coalesce the oldspaces into one. the newspace parameter is more complicated, since newspace can grow incrementally ( assuming growth is not blocked by foreign code ). since growing newspace takes time, you want to ensure that when newspace grows, it grows enough. therefore, it is essential that : expansion - free - percent - new be larger than : free - percent - new. otherwise, you might find newspace growing just enough to satisfy : free - percent - new, and then having to grow again at the next scavenge, since allocating a new object again reduced the free space below the | | at least this percentage of newspace must be free after allocating new newspace. the system will allocate sufficient extra space to guarantee that this condition is met. its initial value is 35. | | | at least this percentage of space must be free in newly allocated oldspace ( note : not the total oldspace ). its initial value is 35. | there are several switches which control the action of gsgc. the value of a switch must be nil. the function gsgc - switch takes a switch name as an argument and returns its value or with setf, sets its also prints out their values. the switches can be set by evaluating ( setf ( sys : gsgc - switch switch - name ) nil - or - non - nil ) | | if this switch is set true, then before expanding oldspace, the system will do a global garbage collection ( that is, it will gc oldspace ) to see if the imminent expansion is necessary. if enough space is free after the garbage collection of oldspace the expansion will not occur. initially | if true, print a message when a gc occurs. can be set by excl : gc. the length of the message is determined by the next two switches. if both are | | if true and | | if true, make the message printed ( when : print is true ) more | | this is the most important of the switches. if true, which is its initial value, gsgc - step - generation is effectively called after every scavenge. thus ( with the default : generation - spread ) an object is tenured after surviving four scavenges. | | | if this switch is true, the function object bound to the variable if this switch is set true, the next gc will be a global gc ( that is


) an object is tenured after surviving four scavenges. | | | if this switch is true, the function object bound to the variable if this switch is set true, the next gc will be a global gc ( that is both newspace and oldspace will be gc ' ed ). after the global gc, the system will reset this switch to the difference between setting this switch and causing a global gc explicitly with the function excl : gc is that setting this switch causes the system to wait until a scavenge is necessary before doing the global gc while calling the function causes the global gc to occur at once. the system uses this switch under certain circumstances. the scavenger maintains a new logical pool of memory in newspace called ` reserved '. when the if : print and : verbose are both true, information about the action triggered by this switch is printed. the information refers to ` hiding ' ( moving space to the reserved bucket ) and ` revealing ' ( moving space to the free bucket ). if this switch is set true and the operating system on which allegro cl is running supports it, then physical memory pages that are no longer used after a garbage collection are given back to the operating system in such a fashion that paging is improved. specifically, when this switch is true and the currently used half of newspace is copied to the unused half, the following things are done with the previously - used memory area : ( 1 ) the operating system is advised to ignore the page reference behavior of those addresses, and ( 2 ) the memory is unmapped and then is remapped, after being filled with zeros. the zero filling is necessary for security reasons, since the memory given back to the operating system will potentially be given to another process that requests virtual memory, without first being cleared. if it were not for ( 2 ), then remapping would always be advantageous and there would be no switch to control this behavior. as it is, there may be certain situations where zero filling will be too expensive, especially on machines which have a very large amount of physical memory and the decrease in locality does not effect the runtime performance of the allegro cl application, or where the mmap ( ) implementation is flawed. if this switch is set true, then a core dump is automatically taken when an internal garbage collection error occurs. the core dump will fail, however, if ( 1 ) there is a system imposed limit on the size of a core dump and dumping


. if this switch is set true, then a core dump is automatically taken when an internal garbage collection error occurs. the core dump will fail, however, if ( 1 ) there is a system imposed limit on the size of a core dump and dumping the image would exceed this limit or ( 2 ) there is some other system impediment to dumping core, such as the existence of a directory named core. we assume that you can prevent the second limitation. here are a few more words on the first limitation. in the c shell, the limit command and its associates can be used to set a higher limit or no limit for the maximum size of a core dump. if the value of this switch is these examples show the effect on gc messages of nil, a message like the following is printed during a : verbose is also true but the message is : : stats is true and nil, the message is similar to : gc : e = 34 % n = 30064 t + = 872 a - = 0 pfu = 0 + 101 pfg = 1 + 0 the same message with : verbose true would be : scavenging... done eff : 9 %, new copy : 148056 + tenure : 320 + aclmalloc free : 0 = 148376 page faults : non - gc = 0 major + 1 minor abbreviations are used. their meanings are explained when : verbose is true. t or tenure means bytes tenured to oldspace. a and alcmalloc free refer to malloc space ( see aclmalloc ). e or eff. is efficiency : the ratio of non - gc time and all time ( the efficiency is low in our example because we forced gc ' s in order to produce the example ; as we say elsewhere, efficiencies of less than 75 % are a cause for concern when the gc is triggered by the system ). the copy figures are the number of bytes copied within newspace and to oldspace. x means " expanding ", so xo means " expanding oldspace " and xn means " expanding newspace ". xmn means " expanding and moving newspace ". page faults are divided between user ( pfu or non - gc ) caused and gc ( pfg or gc ) caused. see the unix man page for getrusage for a description of the difference between major and minor page faults. here are a couple of more examples (


or non - gc ) caused and gc ( pfg or gc ) caused. see the unix man page for getrusage for a description of the difference between major and minor page faults. here are a couple of more examples ( with on and off in a fresh lisp each time ) : cl - user ( 1 ) : ( gc : print ) t cl - user ( 2 ) : ( setf ( sys : gsgc - switch : verbose ) t ) t [... ] cl - user ( 7 ) : ( defconstant my - array ( make - array 10000000 ) ) scavenging... expanding new space... expanding and moving new space... done eff : 36 %, copy new : 7533984 + old : 85232 = 7619216 page faults : non - gc = 1 major + 0 minor my - array ; ; and in a fresh image with : verbose off : cl - user ( 1 ) : ( gc : print ) t cl - user ( 2 ) : ( defconstant my - array ( make - array 10000000 ) ) gc : xn - xmn - e = 32 % n = 7522488 t + = 85632 a - = 0 pfu = 4 + 0 my - array | function or variable | | arguments of functions | | brief description | | gsgc - step - generation | | calling this function, which returns the new value of : current - generation, increases the current generation number and, if necessary, the value | gc | | & optional action | | called with no arguments, perform a scavenge ; called with | print - type - counts | | & optional ( location t ) | | prints a list of quantities and sizes of lisp objects in the specified location in the heap, along with type names and type codes of each object type printed. see the print - type - counts page for location details. | | lispval - storage - type | | object | | returns a keyword denoting where object is stored. see the lispval - storage - type page for interpretation of the returned value and examples. ( in earlier releases, the function pointer - storage - type performed this function. it is still supported, but its use is deprecated. lispval - storage - type is more flexible and should be used instead. ) | | resize - areas


earlier releases, the function pointer - storage - type performed this function. it is still supported, but its use is deprecated. lispval - storage - type is more flexible and should be used instead. ) | | resize - areas | | & key verbose old old - symbols new global - gc tenure expand sift - old - spaces pack - heap | | this function resizes old and newspaces, perhaps coalescing oldspaces, according to the arguments. see the resize - areas page for details. | | | if the gsgc switch : hook - after - gc is true, then the value of this symbol, if true, will be funcalled immediately after a scavenge. see the description of | gc - after - c - hooks | | returns a list of addresses of c functions that will be called after a gc. see gc - after - c - hooks for details. | | gc - before - c - hooks | | returns a list of addresses of c functions that will be called before a gc. see gc - before - c - hooks for details. | in a global garbage collection ( global gc ), objects in oldspace are garbage collected. doing so frees up space in oldspace for newly tenured objects. global gc ' s are time consuming ( they take much longer than scavenges ) and they are not necessary for lisp to run. the effect of never doing a global gc is the lisp process will slowly grow larger. the rate of growth depends on what you are doing. the costs of growth are that the paging overhead increases and, if the process grows too much, swap space is exhausted, perhaps causing lisp to stop or fail. you have complete control over global gc ' s. the system will keep track of how many bytes have been tenured since the last global gc. you can choose one of these options for global gc : the function that records how many bytes have been tenured since the last global gc is the default value of the variable * gc - after - hook *. if you set that variable ( whose value must be a function or nil or a function that does not keep records of bytes tenured, you will not get the behavior described here. ( see the description of information on defining a function that does what you want and records bytes tenured correctly. ) has as its value its initial value or a function that


keep records of bytes tenured, you will not get the behavior described here. ( see the description of information on defining a function that does what you want and records bytes tenured correctly. ) has as its value its initial value or a function that records bytes tenured correctly, global gc behavior is controlled by the global * tenured - bytes - limit * is used in conjunction * global - gc - behavior *. the number of bytes tenured ( moved to oldspace ) since the last global gc is remembered and * global - gc - behavior * depends on when the tenuring macro causes the immediate tenuring ( moving to oldspace ) of all objects allocated while within the scope of its body. this is normally used when loading files, or performing some other operation where the objects created by forms will not become garbage in the short term. this macro is very useful for preventing newspace expansion. it is useful if possible to provide some sort of cue while garbage collections are occurring. this allows users to know that a pause is caused by a gc ( and not by an infinite loop or some other problem ). typical cues include changing the mouse cursor, printing a message, or displaying something in a buffer as emacs does when the emacs - lisp interface is running. unfortunately, providing such a cue for every scavenge is a difficult problem and if it is done wrong, the consequences to lisp can be fatal. however, we have provided an interface for the brave. the functions gc - before - c - hooks and gc - after - c - hooks return settable lists of addresses of c functions to be called before and after a gc. luckily, scavenges are usually fast and so failing to provide a cue may not be noticeable. global gc ' s, however can be slow but it is possible to provide a cue for a global gc even without using c functions. there are two strategies : ( 1 ) determine when a global gc is necessary and either schedule it when convenient or warn the user that one is imminent ; ( 2 ) do not give advance warning but provide a cue when it happens. looking at these examples, you can probably craft your own method of warning or cue. note that in these examples, we replace the value of * gc - after - hook * with a new value, destroying the current value ( which provides for the default automated behavior ). the default function is named by the ( internal ) one way to implement the


these examples, we replace the value of * gc - after - hook * with a new value, destroying the current value ( which provides for the default automated behavior ). the default function is named by the ( internal ) one way to implement the first strategy is to set a flag when a global gc is needed and then have code that acts on that flag. this code can be run at your choosing - - but be sure that it is run at some point. you might do this : ( defvar * my - gc - count * 0 ) ( defvar * time - for - gc - p * nil ) ( defun my - gc - after - hook ( global - p to - new to - old eff to - be - alloc ) ( declare ( ignore eff to - new to - be - alloc ) ) ( if global - p ( progn ( setq * my - gc - count * 0 ) ( setq * time - for - gc - p * nil ) ) ( progn ( setq * my - gc - count * ( + * my - gc - count * to - old ) ) ( if ( > * my - gc - count * excl : * tenured - bytes - limit * ) ( setq * time - for - gc - p * t ) ) ) ) ) make sure you compile my - gc - after - hook before making it the value of * gc - after - hook *. now, define a function that triggers a global gc ( calls ( gc t ) ) when * time - for - gc - p * is true. this function can be called by a user of your application, or when your application is about to do something that the user expects to wait for anyway, or whenever, so long as it is called at some point. in the second strategy, we provide some cue to the user that a global gc is occurring. we have not included the code for the cue ( you should supply that ) and notice we have gone to some pains to avoid a recursive error ( where the garbage collector calls itself ). ( defvar * my - gc - count * 0 ) ( defvar * prevent - gc - recursion - problem * nil ) ( defun my - gc - after - hook ( global - p to - new to - old eff to - be - alloc ) ( declare


( defvar * prevent - gc - recursion - problem * nil ) ( defun my - gc - after - hook ( global - p to - new to - old eff to - be - alloc ) ( declare ( ignore eff to - new to - be - alloc ) ) ( when ( null * prevent - gc - recursion - problem * ) ( if global - p ( setq * my - gc - count * 0 ) ( progn ( setq * my - gc - count * ( + * my - gc - count * to - old ) ) ( if ( > * my - gc - count * excl : * tenured - bytes - limit * ) ( excl : without - interrupts ( setq * prevent - gc - recursion - problem * t ) ; ; ( < change the cursor, print a warning, whatever > ) ( gc t ) ; ; ( < reset the cursor if necessary > ) ( setq * my - gc - count * 0 ) ( setq * prevent - gc - recursion - problem * nil ) ) ) ) ) ) ) ; ; ( < change the cursor, print a warning, whatever > ) ; ; ( < reset the cursor if necessary > ) with whatever code you want, but be careful that there is no possibility of waiting ( for user input, e. g. ) or going into an infinite loop because you are in a without - interrupts form and waiting is wrong and an infinite loop is fatal in that case. the following list contains information and advice concerning gsgc. some of the information has already been provided above, but is given again here for emphasis. nilunless some other method of stepping the generation is enabled ( including specific action by you ). if objects are not tenured, newspace will grow, filling up with long - lived objects, and performance will degrade significantly. : tenure ( which will cause all live objects to be tenured ) or with the tenuring macro. there is no way to prevent a specific object from ever being tenured except by disabling generation stepping and thus preventing all objects from being tenured. it is not easy to cause a gsgc error. such errors are usually catastrophic ( often lisp dies either without warning or with a brief message that some unrecognizable object was discovered ). once the garbage collector becomes confused


an allocation request for 483032 bytes caused a need for 12320768 more bytes of heap. the operating system will not make the space available. [ condition type : storage - condition ] cl - user ( 26 ) : a global gc may free up enough space within lisp to continue without growing. killing processes other than lisp may free enough space for lisp to grow. but it may be the case that other allocations of virtual address space conflicts with lisp usage. please contact franz customer support for assistance in determining whether this is the case if the problem persists. you trigger a global gc by evaluating ( see gc ) : when the garbage collector gets confused, usually by following what it believes to be a valid pointer, but one that does not point to an actual lisp object, lisp fails with a two part message. the first part is a brief description of the specific problem. the second part is a general statement about the gc failures and the fact they cannot be recovered from, along with an opportunity of get a core file ( which may be useful for later analysis ). here are some examples of the second part : the gc ' s internal control tables may have been corrupted and lisp execution cannot continue. [ or ] the internal data structures in the running lisp image have been corrupted and execution cannot continue. [ then ] check all foreign functions and any lisp code that was compiled with high speed and / or low safety, as these are two common sources of this failure. if you cannot find anything incorrect in your code you should contact technical support for allegro common lisp, and we will try to help determine whether this is a coding error or an internal bug. would you like to dump core for debugging before exiting ( y or n )? here are some examples of the first part : system error ( gsgc ) : unknown object type at ( 0xc50ec9a ) system error ( gsgc ) : object already pointing to target newspace half : 0x42c43400 system error ( gsgc ) : scavenger invoked itself recursively. as the text says in the second part, there is no recovery. the causes of such errors can be one or more of the following : diagnosing and fixing the problem can be difficult. here are some initial steps to take where possible : ( gc : print ), see gc. ) if you cannot quickly determine the cause of the problem and a solution for it, contact franz


s are done regularly or that you do an explicit global gc before checking the status of an element of the weak array. we provide a simple example of weak vectors ( weak arrays differ from weak vectors only in having more dimensions ) and finalizations in section 10. 3 example of weak vectors and finalizations. weak hashtables are also supported. see implementation. htm for information on an extension to make - hash - table that creates weak hashtables. the function lispval - storage - type applied to an object returns a keyword providing information about the storage type of the object. weak vectors and finalizations are identified by this function which can be used to test whether an object is a weak vector. a finalization associates an object with a function and optionally queue. if the object is identified as garbage by the garbage collector, either the function is called with the object as its single argument before the object is scavenged away ( if there is no associated queue ) or a list consisting of the function and the object is placed on the queue. in the latter case, no further action is taken by the system. the program must apply the function call - finalizer at its convenience. multiple finalizations can be scheduled for the same object ; all are run or placed on queues if and when the gc identifies the object as garbage. the order of the running of multiple finalizations is unspecified. the timing is important here. while the garbage collector is running, nothing else can be done in lisp. in particular, functions ( except those internal to the garbage collector itself ) cannot be called. therefore, the process of running a finalization and the eventual reclamation of the finalized object occurs over two invocations of the garbage collector. during the first gc, the object is identified as garbage. the garbage collector sees the finalization and so, instead of immediately scavenging the object away, it keeps it alive and makes a note to call the finalization function or enqueue the list of the function and the object as soon as it finishes the current scavenge ( or global gc ). the finalization is removed from the object after the function is run so that during a subsequent garbage collection, the object is either garbage or, if a weak vector points to it, again identified as garbage and ( since it no longer has a finalization ) scavenged away. see the example in section 10. 3 example of weak vectors and finalizations. a finalization is not a type of lisp object


to it, again identified as garbage and ( since it no longer has a finalization ) scavenged away. see the example in section 10. 3 example of weak vectors and finalizations. a finalization is not a type of lisp object. finalizations are implemented as vectors ( but that may change in a later release ). you should not write any code which depends on the fact that finalizations are implemented as vectors. you schedule a finalization with the function schedule - finalization. the function unschedule - finalization removes the finalization from the object. finalizations are only run once, either immediately after the garbage collection which identified the object as garbage or by the program. the object is not scavenged away during the garbage collection in which it is identified as garbage ( since it must be around to be the argument to the finalization function ). on windows, load the file after the transcript example. typing the example into the debug window in the integrated development environment on windows does not work as described, because tools in the ide cause pointers to the objects to be preserved, and, as a result, the example does not work as described. on unix, you can type the example directly to a prompt. ; ; this example can be typed to a prompt on a unix platform. ; ; we define a weak vector and a function to be called by finalizations. cl - user ( 10 ) : ( setq wv ( weak - vector 1 ) ) # ( nil ) cl - user ( 11 ) : ( defun foo ( x ) ( format t " i am garbage! ~ % " ) ) foo ; ; we create an object and put it in the weak vector : cl - user ( 12 ) : ( setq a ( cons 1 2 ) ) ( 1. 2 ) cl - user ( 13 ) : ( setf ( aref wv 0 ) a ) ( 1. 2 ) ; ; we schedule a finalization. cl - user ( 14 ) : ( schedule - finalization a ' foo ) # ( ( 1. 2 ) foo nil ) ; ; we remove the reference to the cons by setting the value of a to nil. cl - user ( 15 ) : ( setq a nil ) nil ; ; we evaluate unrelated things to ensure that the object ; ; is not the value of *, * *, or * * *. cl - user ( 16 ) : 1 1 cl - user ( 17 )


data in a static array is placed in an area that is not garbage collected. this means that the data is never moved and, therefore, pointers to it can be safely stored in foreign code. ( generally, lisp objects are moved about by the garbage collector so a pointer passed to foreign code is only guaranteed to be valid during the call. see foreign - functions. htm for more information on this point. ) only certain element types are permitted ( listed below ). general arrays ( whose elements can be any lisp object ) cannot be created as static arrays. the primary purpose of static arrays is for use with foreign code. they may also be useful with pure lisp code but only if the array is needed for the whole lisp run and the array never has to be significantly changed. the problem is the array is not garbage collected and there is no way ( within lisp ) to free up the space. static arrays are returned by make - array with the ( allegro cl - specific ) allocation keyword argument specified. the data is stored in an area which is not garbage collected but the header ( if any ) is stored in standard lisp space. the following element types are supported in static arrays. bit ( signed - byte 8 ) ( unsigned - byte 4 ) ( unsigned - byte 8 ) ( signed - byte 16 ) ( unsigned - byte 16 ) ( signed - byte 32 ) ( unsigned - byte 32 ) character single - float double - float ( complex single - float ) ( complex double - float ) see implementation. htm for information on this extension to make - array. see lispval - other - to - address for information on freeing static arrays. copyright ( c ) 1998 - 2012, franz inc. oakland, ca., usa. all rights reserved. documentation for allegro cl version 9. 0. this page was not revised from the 8. 2 page. | allegro cl version 9. 0 | unrevised from 8. 2 to 9. 0.


to get the best out of this website, please read on... we have set your language based on your browser language settings or location. to change language use the flag above. we ' d like you to have the best possible experience of our new site, and we notice you ' re using an older browser that isn ' t compatible with some of the latest developments on the internet. we ' ve designed things so free buddhist audio will continue to work for you, but we invite you to a better experience of the web now and in future if you have a few minutes to upgrade... install ( or update from an older version ) a future - friendly browser : audio | view transcript buddhism is the most rational of religions. but it appeals no less to the heart than to the head, using the language of myth to do so. examples are four ' myths ' from the buddha ' s biography, here correlated with four of jung ' s archetypes. this talk is part of the series ritual and devotion in buddhism. | 1. | | seeing buddhism as a whole ( 11 : 54 ) | | 2. | | rationalism in buddhism ( 14 : 11 ) | | 3. | | how does buddhism speak to us? ( 6 : 31 ) | | 4. | | vision and transformation ( 3 : 24 ) | | 5. | | myth and legend ( 6 : 13 ) | | 6. | | myths in the buddha ' s biography ( 4 : 02 ) | | 7. | | the victory over mara ( 5 : 04 ) | | 8. | | the earth goddess ( 4 : 23 ) | | 9. | | brahma ' s request ( 1 : 37 ) | | 11. | | jungian and christian correspondences ( 8 : 52 ) | total running time : 1 : 13 : 54


epilepsy is a chronic neurological condition that causes recurrent seizures. seizures can be a devastating, life challenging condition, however there are many misconceptions about epilepsy. here are 10 things you should know about epilepsy. 1. seizures are more than just physical many people think of seizures as just convulsions. epileptic patients also have symptoms of sensory perception. people may have a feeling of de ja vu, vision changes or become overcome by psychological feelings. 2. seizures knows no age seizures are not just for kids. they can occur at any age. 3. seizures can be a medical emergency if you see someone having a seizure greater than 5 min or not breathing, call 911 for help. do not put anything in the person ’ s mouth. 4. surgical treatment can be an option for some people with epilepsy, surgery can help decrease or eliminate the occurrence of seizures 5. there are reliable resources for information about epilepsy for help and information about seizure disorder and treatment options, contact epilepsy foundation of michigan at www. epilepsymichigan. org 6. blink and you ’ ll miss it some seizures may last just a few seconds and can consist of just a brief stare or quick twitch. 7. medication can help currently there are 20 medications available that help manage epilepsy and more are on the way. 8. the cause may be difficult to find seizures can occur from head injury, infections such as meningitis, high fever, low blood sugar, or some can have no known origin. 9. an epileptologist is a specialist that treats seizure disorders epilepsy monitoring units are available to evaluate and classify seizure types so that the epileptologist can properly treat their patients. 10. you are not alone more than 3 million americans have seizures. how brain surgery can prevent seizures 30 - 40 percent of patients respond well to medication. however in some people, brain surgery might be more beneficial. please take a few minutes to view how brain surgery helped a young lady suffering from epilepsy. chaim colen, md, phd, is the director of neurosurgical oncology and epilepsy surgery at beaumont hospital in grosse pointe, mich. dr. colen ’ s medical publishing company, colen publishing, produces patient and resident educational material and operative dictation templates for emr systems. he is the current chair of the young physicians representative section of the csns and actively involved in socioeconomics in neurosur


is pink turkey meat safe? | | the color pink in cooked turkey meat raises a " red flag " to many diners and cooks. conditioned to be wary of cooked fresh pork that looks pink, they question the safety of cooked poultry and other meats that have a rosy numerous callers to the usda meat and poultry hotline report being alarmed when seeing " pink. " to them, it means " unsafe " " i cooked my turkey until done according to the directions, but when i sliced the breast meat, it was still pink near the bone, " said an oklahoma caller. " is it safe? " " we had a big family argument at thanksgiving dinner. aunt mildred wouldn ' t eat the turkey because it looked pink, " reported the beleaguered cook from a wisconsin family. the color of cooked poultry is not always a sure sign of its safety. only by using a food thermometer can one accurately determine that poultry has reached a safe minimum internal temperature of 165 °f throughout the product. turkey can remain pink even after cooking to a safe minimum internal temperature of 165 °f. the meat of smoked turkey is always pink. to understand some of the causes of " pinking " or " pinkening " in fresh turkey, it ' s important to know first what gives meat its natural color. why is poultry lighter in color than beef? the protein myoglobin is the major pigment found in all vertebrates and can exist in various forms which determine the resulting meat color. the major reason that poultry meat is much lighter in color than beef is that it is dramatically lower in myoglobin. also, as an animal becomes older, its myoglobin content usually increases. turkeys today are young — 4 to 5 months old at the time of slaughter. why are white & dark meat of poultry different the pink, red or white coloration of meat is due primarily to oxygen - storing myoglobin which is located in the muscle cells and retains the oxygen brought by the blood until the cells need it. to some extent, oxygen use can be related to the bird ' s general level of activity : muscles that are exercised frequently and strenuously — such as the legs — need more oxygen, and they have a greater storage capacity than muscles needing little oxygen. turkeys do a lot of standing around, but little if any flying, so their wing and breast muscles are white ; their what causes well - done meat to be pink? - chemical changes during cooking. scientists have found that pinkness occurs when gases


turkeys do a lot of standing around, but little if any flying, so their wing and breast muscles are white ; their what causes well - done meat to be pink? - chemical changes during cooking. scientists have found that pinkness occurs when gases in the atmosphere of a heated gas or electric oven react chemically with hemoglobin in the meat tissues to give poultry a pink tinge. they are the same substances that give red color to smoked hams and other cured meats. the presence of high levels of myoglobin, or some of its redder forms due to incomplete denaturation during heat processing, can account for poultry having a pink to red color similar to that of an undercooked product. - natural presence of nitrites. nitrites are commonly used to produce a desired pink color in traditionally cured meats such as ham or bologna. so it follows that the natural presence of nitrates and nitrites, either in the feed or water supply, used in the production of poultry are a factor in nitrite levels in the birds. one study found that during 40 hours of storage at 40 °f, naturally occurring microorganisms converted nitrate to nitrite. it also found that the local water supply had nitrate and, thus, it could serve as a nitrate source during processing. - young age of meat. often meat of younger birds shows the most pink because their thinner skins permit oven gases to reach the flesh. the amount of fat in the skin also affects the amount of pink color. young birds or animals also lack the shield of a fat covering. meat and poultry grilled or smoked outdoors can also look pink, even when cooked to 165 °f. there may be a pink - colored rim about one - half inch wide around the outside of the cooked meat. the meat of commercially smoked turkeys is usually pink because it is prepared with natural smoke and liquid december 9, 2010


welcome to usda ' s food safety and inspection service food safety at home podcast series. these podcasts were designed with you in mind - the consumer - who purchases and prepares meat, poultry and processed egg products for your family and friends. each episode will bring you a different food safety topic ranging from safe storage, handling, and preparation of meat, poultry and processed egg products to the importance of keeping foods safe during a power outage. so sit back, turn up the volume and listen in. welcome to “ food safety at home. ” this is gertie hurley with the food safety and inspection service. i am your host for this segment. joining me here today is diane van from the usda meat and poultry hot¬line. food safety is important for everyone but especially important for those at risk. diane will give us some practical information to help reduce the risk of foodborne illness for those who are at risk. welcome to the show, diane. thank you gertie. i am pleased to be here. diane " who exactly are the at risk? " gertie, everyone is at risk for contracting a foodborne illness. however, the very young, older adults, pregnant women and their unborn, and those with a weakened or compromised immune system due to illness and / or medication are at greater risk for experiencing a more serious illness or even death should they contract a foodborne how are they more vulnerable? young children have an underdeveloped immune system ; when a woman becomes pregnant her body undergoes hormonal changes causing her immune system to be weakened ; due to the aging process, older adults often experience decreasing function of their systems, including the immune system ; and then there are people who have conditions and / or take medications that weaken their immune system. why is food safety so important for the at - risk? foodborne illness is preventable. while people with normal functioning immune systems may experience diarrhea and other symptoms for a day or so, at - risk populations may experience a lengthier illness resulting in hospitalization or even death. for example, young children who consume a product contaminated with e. coli o157 may experience hemolytic uremic syndrome that can cause kidney failure or even death ; pregnant women who consume a product contaminated with listeria monocytogenes may experience a stillbirth or have a child born with severe medical complications. what are the major pathogens and some associated foods that can cause foodborne major pathogens associated with foodborne illness include for example e. coli


monocytogenes may experience a stillbirth or have a child born with severe medical complications. what are the major pathogens and some associated foods that can cause foodborne major pathogens associated with foodborne illness include for example e. coli, listeria monocytogenes, campylobacter, salmonella, noroviruses, cryptosporidium, toxoplasma gondii, and vibrio what are the symptoms associated with these pathogens? flu - like symptoms are associated with foodborne illness, such as nausea, vomiting, diarrhea, and fever. with some pathogens such as listeria monocytogenes, one may experience a stiff neck ; with e. coli and campylobacter, one may experience bloody diarrhea. because the symptoms may often mimic the flu, if one suspects that they have contracted a foodborne illness they should consult their health care provider or physician for guidance. also, it is important to note that the onset of foodborne illness may take from a few hours to several weeks. it is important for the at - risk and those who provide their care to be aware of safe food handling practices and the symptoms associated with can you give us some examples of the foods that are most risky? yes, uncooked or undercooked meat, poultry, eggs, and seafood products and their juices, contaminated fresh fruits and vegetables, contaminated hot dogs, luncheon meats, soft cheeses and unpasteurized dairy products, smoked seafood and salads made in the store such as ham salad, chicken salad, or seafood salad. what four things would you want the at - risk person or their caretaker to remember in order to reduce their chance of getting foodborne illness? there are four principles that we promote to help consumers reduce their risk of contracting a foodborne illness, and they are the messages of clean, separate, cook and chill. be sure to wash your hands before and after eating, handling or preparing food and keeping all surfaces clean. keep raw or uncooked meat, poultry, and processed egg products and their juices away from ready - to - eat foods and fresh fruits and vegetables to prevent cross - contamination. use a food thermometer to make sure that your meat, poultry, or processed egg product has reached a safe minimum internal temperature ; for example, poultry should be cooked to 165, egg dishes and ground beef should be cooked to at least 160, and steaks / roasts should be


your meat, poultry, or processed egg product has reached a safe minimum internal temperature ; for example, poultry should be cooked to 165, egg dishes and ground beef should be cooked to at least 160, and steaks / roasts should be cooked to 145. keep cold foods cold and hot foods hot. chill leftovers and takeout foods within 2 hours ( within 1 hour in temperatures 90 or above ). use an appliance thermometer to check the temperature of your refrigerator and freezer. the temperature of your refrigerator should be 40 or lower and your freezer 0 or lower. to learn more about the four core food safety messages clean, separate, cook and chill, visit befoodsafe. gov. that ’ s that ' s it for this week. we have been talking to diane van from the usda meat and poultry hotline thank you, diane. i am gertie hurley and i ’ d like to thank you for joining us for this episode of " food safety at home " and remember, “ be food safe. ” well, that ’ s all for this time. thanks for joining us today for another episode of food safety at home! for answers to your food safety questions call usda ' s toll - free meat and poultry hotline at 1 - 888 - mphotline. that ’ s 1 - 888 - 674 - 6854. you can also get answers to food safety questions online from our virtual representative " ask karen " at www. askkaren. gov. let us know what you think of this podcast by sending your comments to thanks for tuning in.


on september 20, 2011, the u. s. postal service launched the save vanishing species stamp, with a beautiful drawing of an amur tiger cub, by artist nancy stahl. the image of the amur tiger cub is perhaps an example that best illustrates the problem and solutions that we have at hand : 60 years ago, the total number of the amur tigers, the world ’ s largest known cat, was down to about 50. some of the causes for this are illegal logging and fires that destroy tiger habitat ( deforestation ) and illegal poaching for use in traditional medicine, and illegal trade. conservation efforts have stemmed this decline. today the estimated population in the wild is 400 amur tigers. the save vanishing species stamp was created to raise public awareness and garner support for critically important global conservation efforts. proceeds from this stamp will directly benefit the us fish and wildlife service ’ s wildlife without borders - multinational species conservation funds, which have funded more than 1, 800 grants for tigers, elephants, great apes, rhinos, gorillas, chimpanzees, and sea turtles. the stamp sells for 55 cents each ( only 10 cents more than an individual first - class stamp ), and $ 11 per sheet of 20 stamps. the proceeds from the stamp are used to save endangered animals in the wild. ten million stamps were printed initially and it will be reprinted based on demand. in just about a year, 16. 5 million stamps have been purchased. it has raised a total of $ 1. 7 million for the five multinational species conservation funds. this stamp is also a celebration of a diverse and fantastic coalition of conservation organizations, private sector, and bipartisan support from members of congress. much effort and hard work was put into the creation of this monumental stamp. this initiative would not have been possible without the 31 member organizations of the multinational species coalition, a group representing over 231 million people who are truly dedicated to the vital importance of wildlife conservation. busch gardens and seaworld has declared this their official stamp. retired congressman henry brown of south carolina and the staff director for fisheries, wildlife, oceans and insular subcommittee of the house natural resource committee, harry burroughs have been champions in congress. the nation ’ s third largest advertising company, bbdo has been a key pro bono partner in planning the communications strategy and creative. also, the 2011 class of a semester in washington, a program at george washington university, developed a public relations strategy and produced public service announcements ( you see below ) to promote this cause. this stamp is a wonderful


weed, weed, weed summer weeds are in full swing now, so try to stay ahead of them. spend just 15 minutes per day weeding, and you ' ll be surprised at how much you can get done. don ' t wait, or you may end up needing to take a week ' s vacation from work just to catch up. use fabric to tie plants tear up an old t - shirt or other soft fabric into strips ( or use purchased plant ties ) to bind climbing roses, tomatoes, and vines to their supports. twine or wire will almost certainly damage plant stems, inviting disease. remove spent rose blooms deadhead roses ( prune off spent blooms ) to encourage plants to produce more flowers. some types of roses have a relatively limited flowering period, while others will continue to bloom all summer long. in either case, it ' s best to deadhead to keep plants looking healthy. water new plants the most common cause of failure in new plants is lack of water. be sure to water new transplants and newly planted trees and shrubs frequently until they get established. during hot, sunny weather, this might mean a deep, thorough watering every few days, especially if your soil drains freely. check soil moisture levels by digging down a few inches. watch for cabbage loopers if the leaves of your cabbage - family plants, including broccoli, cauliflower, and kale, have lots of holes, they ' re probably infested with cabbage loopers or cabbageworms. inspect plants carefully for the light green caterpillars, and / or their dark - colored droppings. use bt - - a biological control that affects only caterpillars - - to control them. ( note that this insecticide also kills other caterpillars, some of which may be the larvae of butterflies you enjoy, so use it sparingly. )


make notes for next year while problems with this year ' s garden are fresh in your mind, jot them down somewhere. note where plants have become overcrowded to help you remember what needs to be moved where next spring. note any sun - loving plants that are now too shaded, and spots where water puddles that need to be amended to improve drainage. or if visuals are more helpful, take photos of problem areas and write notes on the back of them so you ' ll know where to start with redo ' s next spring. take annual cuttings take cuttings of favorite geraniums, coleus, begonias, and any other annual flowers that you want to overwinter for replanting next year. you can also bring these plants indoors for the winter if you have a sunny spot. several popular bedding plants are perennial in warm climates and can be brought indoors as houseplants if you don ' t wait until the weather gets too cool. cold temperatures can set them back and make it hard for them to recover. gradually move the plants into shadier locations so they are better adjusted to the reduced light levels when you move them indoors. sow cover crops as you remove spent plants from your garden beds, sow a cover crop, such as winter rye. this will help reduce weed infestation, minimize erosion and compaction from fall rains, and will add nutrients and organic matter to the soil when it is tilled under next spring. if you ' re making a new bed, it ' s also a good idea to build the soil with a cover crop for a year before planting. till in the cover crop before it goes to seed, either later this fall or early next spring. refresh container plantings if you return from vacation to find tired plantings, you have two choices : cut them back and fertilize and hope they rejuvenate in time for you to enjoy them ; or toss them and start anew ( giving up is not an option yet! ). you can still find annuals at garden centers, or pot up some blooming perennials that you can plant in the ground later in the fall. or consider a combination of foliage plants, such as coleus, that you can bring indoors for the winter. keep watering newly planted trees and shrubs woody plants that you put in this spring or summer need adequate watering for the first year. even when it rains, the moisture might not soak deeply enough to reach the roots and encourage them to spread. the best


prevent blossom end rot blossom end rot shows up as dark, sunken spots on the blossom end of tomatoes, peppers, and squash. it ' s caused by a calcium imbalance in the plant - - the soil may have adequate calcium, but the plant isn ' t able to take up enough to supply the rapidly developing fruit. to minimize the problem, keep soil evenly moist, apply a layer of mulch to conserve moisture, don ' t overfertilize ( especially avoid high - nitrogen fertilizer ), and avoid damaging plant roots while cultivating. dispose of moldy strawberries if you have a strawberry bed, harvest frequently and remove any berries that show signs of grey mold or rot diseases. these berries not only are inedible, they quickly spread the diseases to other ripening fruits. pick and remove the rotten berries and mulch under plants with straw to reduce contact with the ground where the disease spores reside. foil japanese beetles japanese beetles will soon be out in full force, feeding on roses, grapes, beans, and many other plants. control them by handpicking early in the morning or in the evening when they are sluggish, or spray plants with insecticidal soap or neem oil. prune tomato suckers indeterminate tomato plants produce many suckers - - new shoots that start where a branch connects with the main trunk. removing suckers will decrease the number of fruits produced, but the remaining tomatoes will be larger and will ripen sooner. control apple maggots to prevent apple maggot adults from laying eggs on developing apple fruits, place red, sticky spheres ( available from nurseries ) in trees to fool the adults into landing on these fake apples, where they will die. place four spheres per dwarf tree, and check them every few days to clean off the moths.


geol 104 dinosaurs : a natural history fall semester 2012 introduction : what are dinosaurs? what is science? the meaning of fossils review course policies, goals of this course : - use dinosaurs as means of introducing students to key concepts of natural historical sciences, especially evolutionary biology and historical geology - demonstrate the scientific method as it is employed to test questions about the paleobiology, behavior, and extinction of dinosaurs - use the dinosauria as a model of demonstrating patterns of evolutionary divergence and adaptation learning outcomes : by the end of the semester, every student should be able to : - identify the major clades of dinosaurs and their primary attributes ( anatomy, behavior, stratigraphic and geographic distribution, etc. ) - interpret cladograms in determining evolutionary relationships and distribution of specializations - assess claims of inferred dinosaurian behavior, physiology, and extinction patterns from fossil dinosaur science is not archaeology! paleontology, the study of ancient life and their remains ( fossils ). fossils ( from latin fossilium " that which is dug up " ) are the physical remains of past life and its activities preserved in the rock record. vertebrate paleontology, the study of ancient backboned animals, including dinosaurs. the majority of paleontologists, or even of vertebrate paleontologists, are not dinosaur fossils have been found in mesozoic era rocks from every continent, including types of dinosaur fossils : - isolated bones and teeth - skeletons, in varying degrees of completeness - footprints and trackways - skin impressions and feathers - mineralized soft tissue ( muscles, intestines ) - non - mineralized soft tissue!! - eggs ( some with embryos ) and nests - coprolites ( fossilized feces ) the word " dinosauria " ( and hence " dinosaur " ) was coined in 1842 by sir richard - greek deinos " fearfully great " ( i. e., not just big, but scary big! ), and sauros " lizard " - note : hundreds of books to the contrary, owen did not say dinosauria meant owen recognized 3 different dinosaurs : - carnivorous megalosaurus - herbivorous iguanodon - armored hylaeosaurus saw that they were different from other fossil ( and modern ) reptiles because of : - upright limbs - extra hip vertebrae - and a few other skeletal features dinosauria is now recognized as a single major group of organisms, all descendants of a modern definition of dinosauria : the concestor ( most recent common ancestor ) of megalos


- upright limbs - extra hip vertebrae - and a few other skeletal features dinosauria is now recognized as a single major group of organisms, all descendants of a modern definition of dinosauria : the concestor ( most recent common ancestor ) of megalosaurus and iguanodon and all of its descendants thus, dinosaurs are not just " any fossil animals " or " all fossil reptiles " or " all fossil reptiles of the mesozoic " or " all giant fossil reptiles of the mesozoic. " instead, they are specific branch of the tree of life. what is science? - is not simply a body of knowledge - is the empirical ( evidence - based ) way of understanding the natural universe - uses the method of framing and testing hypotheses - proceeds by publication of ideas - allows others to check the original scientist ' s observations - allows others ( including later generations ) to independently test the hypotheses - allows ideas to be widely transmitted the following ( from thomas kida ' s don ' t believe everything you think ) are a useful set of characteristics of thinking like a scientist : - keep an open mind, but be skeptical of any unsubstantiated claim - make sure a claim ( hypothesis ) can be tested - evaluate the quality of the evidence for a claim - try to falsify the hypothesis ( i. e., look for discomfirming evidence ) - observations of natural phenomena lead to possible explanations ( hypotheses ) - these hypotheses must be falsifiable ( i. e., there must be some test, experiment, or observation which can demonstrate that the hypothesis is untrue ) - until the hypothesis is tested, it is only considered a speculation - if the hypothesis survives a test ( or tests ) of falsification, it is tentatively ( or provisionally ) accepted ( keeping in mind that additional tests might potentially overturn - consider alternative explanations - other things being equal, choose the claim that is the simplest explanation for the phenomenon ( i. e., the one that requires the - this is formally known as the principle of parsimony, and also called occam ' s razor - other things being equal, choose the claim that doesn ' t conflict with well - established knowledge - this is sometimes refered to as the principle of consilience - proportion your acceptance of a claim to the amount of evidence for or against a claim the meaning of fossils dinosaur fossils have been weathering out of the rock since long before humans evolved,


this is sometimes refered to as the principle of consilience - proportion your acceptance of a claim to the amount of evidence for or against a claim the meaning of fossils dinosaur fossils have been weathering out of the rock since long before humans evolved, yet " dinosauria " was not recognized until 1842. why did it take this long? before scientists could recognize the existence of dinosaurs, they had to recognize that fossils were the remains of dead ( not alive ), unknown, extinct ( not living anywhere ) organisms. traditional cultures around the world noticed fossils, but assumed they were remains of supernatural creatures ( giants, trolls, mammuts ( a siberian [ yakut ] legendary race of " earth dwellers " : the name is now transferred to fossil elephants! ), during the renaissance and enlightenment in europe, many thinkers began to abandon a view of the mythic past that included monsters and dragons. so what might fossils be? some - " lessons " put there by god, or " tricks " by satan - " sports of nature " : rocks that just happened to look like animal and plant parts - products of the " vital force " of nature ( at this time, many people believed that living things were produced by nicholas steno, a 17th century naturalist, came up with a simple solution : fossils really were parts of dead animals and plants! steno was one of the first people to recognize that rocks were not eternal, but were formed during the history of the earth. so fossils were the remains of living things buried as those rocks formed. but what sort of animals were represented baron georges cuvier ( france ) and contemporaries examined many fossils in the late 1700s / early 1800s : - had access to a wide variety of modern animal specimens as well as fossils - developed comparative anatomy : detailed descriptions of the equivalent parts of different living things - recognized fossils were remains of unknown organisms : that is, they were not examples of known living species - explained them being unknown because they were extinct organisms - examples of unusual extinct vertebrates described by cuvier and contemporaries in the late 1700s and early 1800s included : the stage was set for the discovery of dinosaurs. to next lecture. last modified : 15 august 2012


feature article of monday, 10 september 2012 columnist : anim - mensah, alexander.... threatening 100 million people with almost 100 million people in developing countries exposed to dangerously high levels of arsenic in their drinking water, and unable to afford complex purification technology, scientists have now described a simple, inexpensive method for removing arsenic based on chopped up pieces of ordinary plastic beverage bottles coated with a nutrient found in many foods and dietary supplements. dealing with arsenic contamination of drinking water in the developing world requires simple technology based on locally available materials, " said study leader tsanangurayi tongesayi, ph. d., professor of analytical and environmental chemistry at monmouth university, west long branch, n. j. " our process uses pieces of plastic water, soda, pop and other beverage bottles. coat the pieces with cysteine - - that ' s an amino acid found in dietary supplements and foods - - and stir the plastic in arsenic - contaminated water. this works like a magnet. the cysteine binds up the arsenic. remove the plastic and you have drinkable water. " tongesayi described laboratory tests of the plastic bottle arsenic removal method on water containing 20 parts per billion ( ppb ) of arsenic, which is two times the safe standard set by the u. s. environmental protection agency for drinking water. it produced drinkable water with 0. 2 ppb of arsenic that more than meets the federal standard. the technology is so straight - forward that people without technical skills can use it, tongesayi said, citing that as one of its advantages over some of the existing arsenic - removal technologies. it can use discarded plastic bottles available locally, and the application of cysteine does not require complicated technology. tongesayi is seeking funding or a commercial partner, which he said is the key to moving the arsenic - removing process into use in a relatively short time. the technology also has the potential for removing other potentially toxic heavy metals from drinking water. odorless, tasteless and colorless, arsenic enters drinking water supplies from natural deposits in soil and rock that occur in some parts of the world, including parts of the united states, and from agricultural and industrial sources. symptoms of arsenic poisoning include thickening and discoloration of the skin ; stomach pain, nausea, vomiting and diarrhea ; vision loss ; and numbness in hands and feet. arsenic also has been linked to cancer of the bladder, lungs, skin, kidney, nasal passages, liver and prostate. the above article was published in sciencedaily