Similarly, we also refer to "Merkelized Abstract Syntax Trees", a way of hashing code originally proposed by Pieter Wuille and Russel O'connor(1) that will probably be added to Bitcoin's scripting system eventually.
Pretty much any data structure can have hash functions added to it to "merkelize" it, producing an authenticated data structure: http://www.cs.umd.edu/~amiller/gpads/
Or maybe it's a solution for transaction scriptSig malleability? 
This works because the hash "is" the content/entire subtree (modulo hash collisions), so the resulting data structure has the same meaning as before.
Content/hash-addressed stores are related to referential transparency and immutability (and deep equality) in languages like Haskell, FWIW. I've always thought it's sort of beautiful how cleanly the ideas come together like that.
That is, a block in the bitcoin blockchain is valid not only if its hash matches what one would expect given the included transactions, but that those transactions adhere to the rules of bitcoin. (No double-spends, no dust transactions, etc).
While there are data structures in a git commit that must be present and/or follow a particular set of semantics, git does not enforce anything about the _contents_ of those commits.
Another key distinction: blockchains seek consensus, whereas divergent forks in git repos are by design.
EDIT: I should probably not distinguish too much between consensus and rule enforcement, as those two are obviously intertwined. :)
As long as people want to read what you're publishing, publishing is free. And fast. Around the planet. The web is about to get way better, and IPFS and its competitors are going to be what pushes it forward.
In the very near future, the entire New York Times archives will be fetchable just by asking for it. Your computer will ask your neighbor for the front page for July 21, 1969, and they'll send it right over.
Yeah-- the IPNS records have a notion of recency, as well as being able to write version history datastructures (e.g. git)
The only reason GitHub is an intermediary and single point of failure is because it's much more convenient than raw git. There's nothing that stops you from dropping your git repo on a webserver, Amazon S3 bucket, or any other data store. Heck, my last startup used Heroku as our master git repository because we didn't want to pay for a private GitHub repository.
Here's a writeup: https://github.com/ctfs/write-ups-2014/tree/master/stripe-ct...
A Gitcoin miner updates the ledger (a text file in the repo), and "mines" the next-smaller hash.
It doesn't have consensus, but it does give a neat programming challenge.
Bitcoin is like Git: in Git (a distributed version control system) all your changes are organized in a chain protected by cryptographic hashes. If you trust the latest hash, you can get all the previous information (or any part of it) from any source and still verify that it is what you expect. Similarly, in Bitcoin, all transactions are organized in a chain (the blockchain) and once validated, no matter where they are stored, you can always trust any piece of blockchain by checking a chain of hashes that link to a hash you already trust. This naturally enables distributed storage and easy integrity checks.
Bitcoin is unlike Git in a way that everyone strives to work on a single branch. In Git everyone may have several branches and fork and merge them all day long. In Bitcoin one cannot “merge” forks. Blockchain is a actually a tree of transaction histories, but there is always one biggest branch (which has the value) and some accidental mini-branches (no more than one-two blocks long) that have no value at all. In Git content matters (regardless of the branch), in Bitcoin consensus matters (regardless of the content).
* receive all the transactions (or their hashes) that occurred
* sign this with some HMAC, and publish it
* then we know that the transactions occurred by X time
And what if it was included by some in the network but not others? How do we know some are not cheating?
That's where proof-of-work comes in. You can also have proof-of-stake and other mechanisms, by which to solve the Byzantine Generals problem. How do we know that the signers aren't cheating? Who watches the watchers?
But if you're not signing any black- or grey-hat documents or transactions, then you can just pick a trustworthy central party to receive the hashes and publish the chain.
The startup GuardTime has been doing document timestamping and integrity checks with a blockchain for a bit while longer than bitcoin.
* You hash documents that you want to timestamp, and send the hash to them.
* They hash all received hashes and the previous head of the blockchain together, and publish the head hash in the paper copy of Financial Times: https://guardtime.com/photos/ft14-2.png
* The exact contents and "created before than" timestamp of the documents can now be fully verified, unless someone can manage to gather and destroy all paper copies of Financial Times published after it was sent to them.
The incentive for them is an usual freemium payment model.
In Git you can change history. So I don't think Git can be called a blockchain, although it shares the sames concepts, like the merkle tree.
The result for both is the same, both of them will throw errors if you attempt to pull data from a git repo or blockchain which has invalid hashes that don't match the ones you already have - This is why it's a problem if someone decides to use rebase on a public branch that people are pulling from, the hashes will change and people will get errors when they try to pull because the histories don't match.
PoW (Proof of Work) makes it impossible to just "replay all the subsequent transactions that happened", because your fake chain will have significantly less proof of work.
Launch Gitcoin.com. The company's shares are called gitcoins which is a premined cryptocurrency by gitcoin.com. The aim of the company is to balance the distribution of shares according to their value, to maximize its own value. Parties who support this company's cause or want to gain a monetary incentive out of the value that gitcoin would gain would mine gitcoins or buy them in exchanges.
Authors publish the meta data about their content hashed with any private key they want. Each of these private key is a separate logical 'view' for showcasing the Authors content. For eg, one private key each for friends, business and everyone, so that one category cannot view the contents of the other, and the share the respective public keys with concerned parties using any medium. The aim would be to earn gitcoins and go and sell them at an exchange to earn a living wage.
The consumers of code would pay for the code they want to view to the public key, which is also a gitcoin address, which they already have! This automatically sends gitcoins to the author.
All code is open to everyone. If you have a public key you can view its associated code and change it, by sending money to it. Gitcoin.com takes a cut in providing this service.
This website also invents two brand new features in a website - no password and no captcha!
- No Password because you can view any code if you send money to it. Authors will keep the rates very high and share a new private category's public key to people they wanna give discount to. You can have as many identities you like and can club, fork and terminate them.
- No Captcha because captchas were invented to prevent robots. But robots are not always bad. So we want people to build helpful reddit-like robots but not bad ones. Gotcon.com solves this by allowing all robots according to an economic incentive motive. For ex, a user can build a good robot that shows the issues list corresponding to a gitcoin address. People pay this robot in gitcoins and so this robot has enough gitcoins to open the community desired code. But if a bad robot tries to spam this good robot, people will simply create a new address and copy all previous data and move to it, all of this at a click of 'block' button.
So basically, by changing the behavior of block button to create a decentralised copy of gitcoin.com itself and then moving to it eliminates the bad actor immediately and making it yet expensive for him to keep paying to see the code.