Several people have argued that multiplication by gridding is more natural and they came up with it themselves after having learnt the old way. So did I, but I'm inclined to think that I came up with because I had plenty of multiplication practice in the first place.

Most people are familiar with the idea of coming up with a loose approximation of the answer, then working it out exactly, and for that you are basically doing the same thing. Gridding is like big-endian multiplication - you start with the most significant bits and refine towards a solution, whereas traditional multiplication is little-endian. I suspect that this became the norm not because older math teachers are sadists, but because if you get a traditional multiplication calculation badly wrong (in terms of not understanding the process), it'll be screamingly obvious, whereas if you make an error with the gridding method it will still look like a good approximation...those kind of errors turn to be expensive in the real world, so trapping them early is a good idea.

Yes, we do need fewer fads and more evidence...and we also need to stop thinking that there is one eternally best method for doing things. If you use the traditional method to multiply two large numbers, your calculations will extend down the page. If you use the gridding method, your calculations will extend sideways (total = a +b +c +d +...). In both cases you are trying to reduce the problem to single-digit multiplication and use base-shifting. The traditional way is little-endian (least significant bit): you multiply, add/carry and shift, for big-endian you shift and multiply, but you have to perform more addition operations at the end. What we're doing with numbers and digits resembles what a CPU does with bytes and bits when dealing with floating point math.

I can multiply 2 4 digit numbers in my head by either method, but if accuracy matters then I prefer the little-endian one because you increment your exponent based on the depth of your stack. So if you multiply two integers with m and n digits you end up with a stack of depth n. The numbers on the stack look more complex than with gridding, but none of them will have more than m + 1 new digits (zeros at end added by you) and you only need one register and one carry digit. If you go with the other method you end up with a final stack of length m * n - with ~half of them being zeros, which is your information penalty for postponing the addition and carrying operations (although only m * n are significant carries, the others are incremental ones when a carry + product goes over a decimal boundary - eg if we carried 7 and next multiply 6 x 9, 54 + 7 = 61 and we carry 6 instead of 5).

Would you rather do m single-digit multiply-adds n times followed by m additions of n terms, or or m * n single-digit multiplications and base power additions, followed by adding up m * n terms? For small numbers it's not a big deal, but if you multiply two 4 digit numbers you're going to have add up a string of 16 numbers at the end.

Indeed, you could do the little endian method by gridding too; the numbers on each line in long multiplication are the totals of the grid columns read from the bottom right. But multiplying any number by a single digit is easy. We add numbers with a little-endian method because otherwise we'd have to keep stepping backwards to update the leading digit. As a bonus we know from the first digit that the numbers are correctly aligned if we arrange them vertically, rather than adding 300 to 4000 to get 700? - oops). By multiplying and adding the carry as we go along we're just extending that technique, and we still get the benefit of the ordinal alignment instead of writing down all those zeros - we just have to remember to pad each new line with one extra zero.

The grid method encourages people to start multiplying numbers on the left...which will then have to be added up by working from the right. If you made any errors with the large # of zeros you are going to be screwed; multiple digits will be corrupted and the total will be significantly farther away from the correct answer. Considering that multiplying 2 4-digit numbers will yield 42 zeroes spread over 16 products vs 6 over 4 for the traditional method, I'd say it multiplies the potential for a mistake.