Plutonic Rainbows

A script that gets a basic blockchain up and running.

import hashlib as hasher

class Block:
  def __init__(self, index, timestamp, data, previous_hash):
    self.index = index
    self.timestamp = timestamp
    self.data = data
    self.previous_hash = previous_hash
    self.hash = self.hash_block()

  def hash_block(self):
    sha = hasher.sha256()
    sha.update(str(self.index) + 
               str(self.timestamp) + 
               str(self.data) + 
               str(self.previous_hash))
    return sha.hexdigest()

import datetime as date

def create_genesis_block():
  # Manually construct a block with
  # index zero and arbitrary previous hash
  return Block(0, date.datetime.now(), "Genesis Block", "0")

def next_block(last_block):
  this_index = last_block.index + 1
  this_timestamp = date.datetime.now()
  this_data = "Hey! I'm block " + str(this_index)
  this_hash = last_block.hash
  return Block(this_index, this_timestamp, this_data, this_hash)

Create the blockchain and add the genesis block
blockchain = [create_genesis_block()]
previous_block = blockchain[0]

How many blocks should we add to the chain
after the genesis block
num_of_blocks_to_add = 20

Add blocks to the chain
for i in range(0, num_of_blocks_to_add):
  block_to_add = next_block(previous_block)
  blockchain.append(block_to_add)
  previous_block = block_to_add
  # Tell everyone about it!
  print "Block #{} has been added to the blockchain!".format(block_to_add.index)
  print "Hash: {}\n".format(block_to_add.hash)

Apple engineer explains the story about how this small but extremely useful function came into being.

Some sound advice from Wired UK:

A phone battery is made up of two layers, one of graphite and the other of lithium cobalt oxide. Energy releases when lithium ions move from the graphite layer to the lithium cobalt oxide layer. Charging up a battery shifts the lithium ions back the other way, preparing the process to start again.

What you this tells us is that the real sweet spot for a battery is a 50 per cent charge – when half of the battery’s moveable lithium ions are in the lithium cobalt oxide layer and the other half in the graphite layer. This equilibrium puts the least amount of strain on the lithium ions that power your battery, and basically extends the number of charge cycles it can take before degrading. Therefore it’s best to keep your your battery between 20 and 80 per cent, and regularly top up with partial charges.

The article also talks about badly engineered apps and the downside of trickle charging - which is what I was doing with the Belkin.

Decided to buy a Belkin Wireless Charger two weeks ago and it already seems to have had a detrimental health on the XS Max battery capacity. I’ve previously had 100% capacity for almost a year.

Actually, looking at my diary it is exactly a year ago today that I bought the XS Max, so it’s disappointing that I couldn’t keep the 100% record intact - which I’d achieved by careful battery management. Which brings me back to the Belkin and its effect on battery capacity for the iPhone.

Within fourteen days, it has fallen to 98%. This is due to trickle charging.

According to Battery University, leaving your phone plugged in when it's fully charged, like you might overnight, is bad for the battery in the long run.

Once your smartphone has reached 100% charge, it gets "trickle charges" to keep it at 100% while plugged in. It keeps the battery in a high-stress, high-tension state, which wears down the chemistry within.

I’m going back to my old way of just using the 30W USB-C every few days and try and put the thought of the £50 I spent behind me.