Add some usage documentation

Mentions the `ipfs.Buffer` field you can use to stamp out `Buffer`s so you can actually insert stuff given just an `IPFS` instance and no Node.js APIs in scope.

Author: interfect

README.md

@@ -110,7 +110,114 @@ The last published version of the package become [available for download](htt
 
 ### Examples
 
-> **Will come soon**
+Below are spome examples of JavaScript IPFS in action.
+
+#### Startup (in Node.js or browser)
+
+There's still a bit of work required to start up a node in a robust way (i.e. without requiring the user to manually `js-ipfs init`). Here is one way to do it.
+
+```javascript
+// Find the IPFS implementation
+var IPFS
+if (!(typeof require === 'undefined')) {
+  // Can load through Node
+  IPFS = require('ipfs')
+} else if (!(typeof Ipfs === 'undefined')) {
+  // Can load through browser global
+  IPFS = Ipfs
+}
+
+// Make an IPFS node
+var ipfs = new IPFS()
+
+// Init a repo in the given IPFS node it if hasn't got one already. Calsl the
+// setup callback, passing the normal callback, after first initialization.
+// Calls the normal callback directly after subsequent initializations. Calls
+// the normal callback with an error parameter if there is an error.
+function initIfNeeded (ipfs, setup, callback) {
+  ipfs.init((err) => {
+    if (!err) {
+      // This is the first time we have started a node
+      setup(callback)
+    } else if (err.message == 'repo already exists') {
+      // The node already exists
+      callback()
+    } else {
+      callback(err)
+    }
+  })
+}
+
+// Init the node
+initIfNeeded(ipfs, (callback) => {
+  // On first initialization, do some setup
+  // Get the node config we just init-ed
+  ipfs.config.get((err, config) => {
+    if (err) {
+      throw err
+    }
+    // Add at least one libp2p-webrtc-star address. Without an address like this
+    // the libp2p-webrtc-star transport won't be installed, and the resulting
+    // node won't be able to dial out to libp2p-webrtc-star addresses.
+    var star_addr = ('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/9090/ws/ipfs/' +
+      config.Identity.PeerID)
+    ipfs.config.set('Addresses.Swarm[1]', star_addr, (err) => {
+      if (err) {
+        throw err
+      }
+      // Continue down the already-initialized code path
+      callback()
+    })
+  })
+}, (err) => {
+  // If the repo was already initialized, or after the first-time initialization
+  // code is run, we'll do this.
+  if (err) {
+    throw err
+  }
+  // Have the node set itself up
+  ipfs.load(() => {
+    // Go online and connect to things
+    ipfs.goOnline(() => {
+      console.log('Online status: ', ipfs.isOnline() ? 'online' : 'offline')
+      // TODO: Write your code here!
+      // Use methods like ipfs.files.add, ipfs.files.get, and so on in here
+      // Methods requiring buffers can use ipfs.Buffer
+    })
+  })
+})
+```
+
+#### Adding a file
+
+Once you have an IPFS node up and running, you can add files to it from `Buffer`s, `Readable` streams, or [arrays of objects of a certain form](https://github.com/ipfs/interface-ipfs-core/tree/master/API/files#add). If you don't have `Buffer` conveniently available (say, because you're in a browser without the Node API handy), it's available as a property of the IPFS node.
+
+```javascript
+// Add a single file
+ipfs.files.add(ipfs.Buffer.from('Hello world'), (err, returned) => {
+  if (err) {
+    throw err
+  }
+  console.log('IPFS hash: ', returned[0].hash)
+})
+```
+
+#### Retrieving a file
+
+To retrieve the contents of a file, you can use the [cat method](https://github.com/ipfs/interface-ipfs-core/tree/master/API/files#cat), which will call your callback with a Node.js-style `Readable` stream.
+
+```javascript
+ipfs.files.cat('QmNRCQWfgze6AbBCaT1rkrkV5tJ2aP4oTNPb5JZcXYywve', 
+  (err, content_stream) => {
+
+  if (err) {
+    throw err
+  }
+  content_stream.on('data', (buffer) => {
+    console.log('File contents:', buffer.toString('ascii'))
+  })
+})
+```
 
 ### API
 
@@ -187,6 +294,8 @@ IPFS Core is divided into separate subsystems, each of them exist in their own r
 
 IPFS Core is the entry point module for IPFS. It exposes an interface defined on [IPFS Specs.](https://github.com/ipfs/specs/blob/ipfs/api/api/core/README.md)
 
+This particular implementation also provides some extensions to assist with usage in a browser, such as the `Buffer` type, required as input for some API methods, being available as `ipfs.Buffer` on every `IPFS` object.
+
 #### Block Service
 
 Block Service uses IPFS Repo (local storage) and Bitswap (network storage) to store and fetch blocks. A block is a serialized MerkleDAG node.