You need to do the explicit propagation after every single line that might generate an error. That seems to me to lead to a lot of boilerplate code, and it would be easy to forget or mess up one of these lines.
I kind of see Joels point though, that if you write:
openFile();
doSomething();
closeFile();
Then it is not obvious by just looking at these lines in isolation, that the file may not be released. If you already have the throws clause in the signature for some other reason, you might miss this.
I don't think boilerplate error handling is the right solution for this though. Boilerplate just gives you boilerplate-blindness.A language for programming nuclear devices like Joel hints at, might make the throws clause explicit on every method call:
openFile();
doSomething() throws IOErrors;
closeFile();
(Don't know if any language has this syntax, but at least it makes the throw obvious in a much safer way.)However I prefer something like the using pattern in C#:
using (file) {
doSomething();
}
(Same as "with" in python.)
I find this the ideal solution, since you don't have to worry about whether the method may throw exceptions at all, the file will always close correctly. And regardless of exceptions, the syntax guarantees that you don't forget to close the file.