How exactly is this:
easier to understand, in any sense, than this?
profit = income - losses
In fact, there is several things that are easier to understand.
First you don't have to worry about the types of income, losses, profit, you know that they they are the size of the accumulator.
Then you don't have to worry about how the - opperator is implemented, and how it will react to overflow/underflow, because this is specified by the SBC instructions which has a completely defined behaviour.
In some of the langages that are, in my opinion, hard to understand, the "-" could call an operator overloading function that would take the objects as arguments, etc... and this like could potentially generate 32kb of code instead of 7 bytes (again, depending on the types).
Object references and copying are something that is especially complex to understand, and I suspect that less than 10% of people who speaks the language actually know what they are doing. Of course, don't include me, since I'm explicitely stating I'm not understanding this, but at least I know that I don't understand it - the most dangerous thing is to think
you understand something you don't.
In this regard, high level OOP languages are extremely good at this : They are simpler to work with and make people think
programming is easy and that they understand perfectly what they're doing.
The result of this is programs taking 100 times the memory they should take (both code size (hard disk) and data size (run time heap memory)), memory leaks, unpredictable execution speed and very nasty bugs.
This is just my opinion, it's fairly incomplete as I am not so experienced with so many languages, and anyone is free to disagree. But this is why I think low level is easier to understand - but not easier to program with.