Hi! It's very common to have the same structure when handling resources that should be disposed after using -normally when they belong outside the image- like files, aliens, database transactions, mutex semaphores... *[ open the file do something with the file ] ensure: [ close the file ] **[ create an alien do something with the alien ] ensure: [ free the alien ] * * [ open the transaction do something with the transaction transaction commit ] ensure: [ transaction if open, transacction rollback. ] * Some times, this structure is abstracted in a high order method(?) using blocks.. *session inTransactionDo: [ "do something with the transaction" ] Semaphore forMutualExclusion critical: [ "do something with the semaphore ]* Ok, Python and C# add the *with* and *using* statement, handling the resource disposing in a polymorphic way block of code is executed, like: with aFile: #use the file or using (aDatabaseTransaction){ /* use the database transaction */ } Even in Java 7 they've included a construction for auto-dispose of resources: *try (BufferedReader br = new BufferedReader(new FileReader(path)))* { return br.readLine(); } What about adding a polimorphic (for example) #releaseAfter: method like *Object>>releaseAfter: aBlock self retain. [ aBlock cull: self ] ensure: [ self dispose ] Object>>dispose "hook for disposable resources" ** Object>>retain "hook for resources which can be retained"* * Alien>>dispose self free **File>>retain self open* * File>>dispose self close Stream>>dispose self close Transaction>>dispose self isOpen ifTrue: [ self rollback ] * And so? this way resources can be handled in an uniform way. Cheers, Guille