Property exists, according to Hans-Hermann Hoppe, to avoid conflicts over scarce resources. Property allows human beings to avoid constantly fighting each other over the same plot of land, the same cow, or the same hammer. Someone is the owner, and there’s a protocol for the legitimate transfer of title from one person to the next. A simple rule almost everyone can comprehend orders our behavior to prevent most conflicts before they start. I don’t take Sue’s hammer because it’s hers.
In computer programming, scarce resources are also a potential source of conflict. A program is constantly appropriating portions of memory (called allocation), doing work with the data it stores there, and then telling the system it’s done using that portion (called deallocation). If those steps aren’t taken carefully, different programs, or even parts of the same program, will try to use the same location in memory, creating a lot of problems.
Normally, either the programmer is responsible for anticipating these conflicts and addressing them explicitly, or there is an extra process running alongside the program, called a garbage collector, that performs the “deallocation” job so the programmer doesn’t have to remember to do it. The latter is convenient, but it comes at the price of a slower program.
In the human world these approaches would be akin to either memorizing a script that tells me what to do in all situations, or having a third person monitor me while I act on impulse, constantly updating Sue about the status of her hammer. Property works great for humans because a simple, universal rule takes a lot less energy than trying to monitor or anticipate every possible problem.
The relatively new Rust programming language manages to capitalize on this ancient human innovation. In a sense, it thinks of memory as property. It enforces a policy the creators call ownership. Details are available here. To make a long story short, only one part of your program at a time is allowed to read and write to a particular piece of memory. Title to that data is passed around to the other parts of your program as needed, but your code will not be allowed to run in the first place if one part is instructed to use data without owning it first. To the astonishment of some in the computing world, this prevents a lot of common mistakes without imposing a cost on speed. To an Austrian, it is no surprise that this approach solves a number of hard problems.