I noticed that sending a transaction actually means sending your entire wallet amount to the person and you get change back? I just noticed that when you send an amount to someone. You actually send them the entire wallet amount and then it gets sent back as change. Is this true and why was it implemented in this way?

Also since it gets sent back as change, how would this affect a paper wallet? Does the same apply? Currently I have a paper wallet and I sent some coins to another wallet from my paper one. I hope everything is still safe.
Requiring an output to be fully consumed by a single transaction simplifies things -- an output is either spent or unspent, period. The idea is to avoid a proliferation of partially unspent outputs that would be very difficult to track. If a transaction could partially consume an output, then you'd have a whole new category of partially unspent outputs, each potentially partially consumed in some number of places.

It is possible to send the "change" to the original receiving address. If you do that, the paper wallet will still contain the key to access the new change outputs. If you use a new address for the change, then the paper wallet will be unable to spend the change. (Unless it's a complex type of deterministic wallet, which I very much doubt.)

With the current system, each output is either consumed by a transaction which has it as an input or it is unconsumed and is a valid output to be consumed by a future transaction. With partial spends allowed, each output could be partially-consumed by any number of other transactions, making the system much more complex.

Current System:


You get a check for $100. You now have a $100 unspent output.
You send $10 to a friend by consuming the $100 and sending $90 to yourself. The $100 check is now fully consumed. You have one output for $90 and nobody cares about the check anymore.
You send $20 to a friend by consuming the $90 and sending $70 to yourself. You now still have only one output, both previous outputs are fully consumed.


Notice how the state stays simple at all times? Every output is either fully-consumed or untouched.

System with partial consumption:


You get a check for $100. You have a $100 unspent output.
You send $10 to a friend. To understand that you have $90 left, we need to look at both the $100 check you got and the $10 you sent to a friend.
You send $20 to a friend. To understand that you have $70 left, we need to look at the $100 check you got, the $10 you sent in step 2, and the $20 you sent now.


Notice how the system's state is getting much more complicated? To understand what is left of the $100, we have to look at two other transactions that partially consumed it.

It's just much simpler to fully consume and replace with a new, smaller unspent output than have to track partial consumption across two places.

Worse, imagine if you got two checks for $10 and wanted to send $15 to a friend. Now we'd have to look in three places to know what was left -- both checks and the $15 you sent to a friend to figure out you have $5 left. It's much, much simpler to just destroy the original checks and issue you a $5 payment to yourself. Now, we know the checks are dead because a transaction touches them. We know the $5 payment to yourself is good because nothing touches it. Everything is either spent or unspent. Simple.