DEV Community: Jonathan Thomas

My Journey Through Tech: Junior IT Analyst Program day 60

Jonathan Thomas — Fri, 27 Mar 2020 09:12:04 +0000

It has been quite some time since my last posting. The cohort is going extremely well. As of writing, I have completed the Core 1 exam for Comptia’s A+ certification. This is the first real step I’ve taken to having my skill verified. The only difficulty at this time is the global pandemic that is the corona virus. Due to it’s spread across the globe, my country has insitigated a nation wide quarantine. While this has essentially ground life in this country to a halt, it has not stopped the cohort from continuing.Like it or not, we are deternimed to become Junior Information Technology Analyst.

The staff at NPowerCanada have set up work from home criteria in which we are still expected attend and complete. We’ve switched over to remote learning. For now this has offered some repreive as I find myself being able to focus on the Core 2 modules on my own. A downside, unfortunately, is that there seems to be a lot more impatient from some of the other cohort attendees.Regardless my journey through tech continues uninterrupted.
My Pressing Concerns

While it is a challenging situation that the entire world is facing right now, I am a bit worried about my own employment prospects. Since completing Core 1, candidates were being setup for infield placements, sadly that has been upended in part due to corona. Upsetting as it may be, it’s a chance to work on my own personal branding. When I’m not studying the rest of the IT materials, I’ve actively started working on making a freelance portfolio. Through out my journey through tech personal branding is an area I must work on.

I had also started looking into crowdsourced employment for the time being. Furthermore it’s been about 3 weeks since I last touched the blockchain development course. I plan on resuming that monday but have been refreshing my skills by going onto typing.io and couple of coding books from a recent humble bundle purchase.Since the junior information technology analyst program is designed for entry level, it is important that I get better typing to make documentaion easier.
Plans after the cohort?

The major one is to continue on improving my freelance profile and networking through NPowerCanada. I know that if I do land a job within the next couple of months, I’ve seriously thought about investing in education. Currently I’m looking at Gerogebrown’s Robotics Technician program and Coursera Plus. The reason I’m looking at them now is due to the corona pandemic. Learning to maintain and program robots aligns with my values.The days of doing one thing only and expecting employment has not existed for a lot of decades. By proactively gettting experience and accreditation both both fields, I develop an interdisciplanay skillset. My journey through tech has shown that if I want to increase my chances, I have to always be learning.

These two options are also distance based and cost effective. The George Brown Robotics Certification program is self-paced and simulation based. Once I get a new laptop with required specifications I can see myself enrolling. At the same time, Coursera Plus, has an annual subscription that allows me to access several industry recognized specializations. I completed the Google IT Support Specialization in 2018. The specializations such as cybersecurity, robotics, mathematics for machine learning, artificial intelligence, embedded systems/sensors and cloud engineering would give me access to the type of education I’ve always dreamed of, but could never afford.

Preparing for a Digital Revolution

These last couple of months have really been eye opening. I realize now just how much of my time and potential I was wasting from drinking. The pain of not living up to my own expecations is no longer present. Rather than despair, there is hope. I’ve approached 200 plus days of alcohol sobriety and will reassess at 270 day. At this rate I’m wlll on my way to making it to a full year without booze.

Furthermore, I’ve actually started reassessing my creative goals. I took a step back from drawing again but plan to start back over the weekend. In the meantime I’m going to be writing out a couple of scripts for youtube and using the creative community I’m a part of more frequently. As such I now have some comic ideas again after 2 months. I’m starting to take Japanese seriously again and started a plan for that.

I’ll use the next two weeks of quarantine to catchup on niche skillsets, create some type of content and work on my branding.

The real concern however is will I be able to translate the technical skills into something higher than junior information technology analsyt?

I admit, it’s going to be rough but I have time to build my autonomy for the future.

Thanks for reading

My Journey through Tech: FullStack Blockchain course Section 3

Jonathan Thomas — Thu, 27 Feb 2020 12:40:47 +0000

Continuing on from the last section, it appears that I needed to add a few more describes to our replaceChain description in the blockchain.test.js file like so:

describe('replaceChain()', () => {
let errorMock, logMock;

  beforeEach(() => {
      errorMock = jest.fn();
      logMock = jest.fn();

      global.console.error = errorMock;
      global.console.log = logMock;
  });

    describe('when the new chain is not longer', () => {
        beforeEach(() => {
            newChain.chain[0] = { new : 'chain'};

            blockchain.replaceChain(newChain.chain);
    });
      it('does not replace the chain', () => {

        expect(blockchain.chain).toEqual(originalChain);
        });

        it('logs an error', () => {
            expect(errorMock).toHaveBeenCalled();
        });



        describe('when the chain is longer', () => {
            beforeEach(() => {
                newChain.addBlock({ data: 'Bears'});
                newChain.addBlock({data: 'Beets'});
                newChain.addBlock({data: 'Battlestar Galactica' });
            });

            describe('and the chain is invalid', () => {});
                beforeEach(() => {
                    newChain.chain[2].hash = 'some-fake-hash';

                    blockchain.replaceChain(newChain.chain);
                });
                it('does not replace the chain', () => {

                    expect(blockchain.chain).toEqual(originalChain);

                });

                it('logs an error', () => {
                    expect(errorMock).toHaveBeenCalled();
                });

            describe('and the chain is valid', () => {
                beforeEach(() => {
                    blockchain.replaceChain(newChain.chain);
                })

                it('replaces the chain', () => {
                    expect(blockchain.chain).toEqual(newChain.chain);
                });

                it('logs about chain replacement', () =>{
                    expect(logMock).toHaveBeenCalled();
                })
            });
        });
    });
})

});

We set the global values of the error output to be stubbed using the jest.fn() built-in. We set the variables, errorCheck and logCheck to be globally accessible. The idea is that, this module will quiet the error outputs on the command line. As of writing, the current replaceChain test fails because the erroMock, is expecting to be called but not found. Currently I have reached out to fellow learners and the course instructor for solutions. As well, I've taken the initiative to read up on the jestJS documentaion for a solution.

From what I've gathered from my readings, this is a bug that seems to be common in versions of jest <= 23.0.6, which is currently part of my dependcy file.I'll test with a current version of jest later tonight.

Proof of Work portion

Before getting back into code we got introduced to the proof of work theory behind cryptocurrency. The proof of work system was based on hashcash a concept designed back in 1997. The premise of which is, that any hashes generated from data has a difficulty rating assigned to it. The higher the difficulty, the more computing power needed to decrypt the hash.
In the case of block hashes, we are looking for hashes with leading zeroes that that can match up to a number used once(nonce) that is generated from our data.

The idea that anyone who wants to solve thes hash problems uses their computer's resources to match the hash.Using bitcoin as an example, the network of bitcoin is set to release a new block every 10 minutes. During that time, people who are trying to solve a hash on a newly released block contribute their computing power. The more that you can contribute, the greater the chance that a portion of the reward goes to you for decrypting it.

However, this could lead to being exploited by a 51% attack. The concept behind this attack is that a malicious block is inserted into the chain that has a greater amount of resources contributing to decrypting th hash.

Updating the block.test.js

While back inside out block test file we add two more tests they are nonce and difficulty tests to the block.test.js file:

describe('Block',() => {
const timestamp = 'a-date';
const lastHash = 'foo-hash';
const hash = 'bar-hash';
const data = ['blockchain', 'data'];
const nonce = 1;
const difficulty = 1;

const block = new Block({timestamp,lastHash,hash, data, nonce, difficulty});

We updated the block object as well to refelct the new values.

We then updated the SHA 256 has test to refelct the nonce and difficulty like so:

it('creates a sha-256 hash based on proper inputs', () => {
expect(minedBlock.hash)
.toEqual(
cryptoHash(
minedBlock.timestamp,
minedBlock.nonce,
minedBlock.difficulty,
lastBlock.hash,
data
)
);
});
And then we finally added a hash matching test to match for the difficulty of the block:

it('it sets a hash that matches the difficulty criteria', () => {
expect(minedBlock.hash.substring(0, minedBlock.difficulty))
.toEqual('0'.repeat(minedBlock.difficulty));
});
});

We then set an initial difficulty within the config.js with the added nonce and diffictulty values:
const INITIAL_DIFFICULTY = 3;

const GENESIS_DATA = {
timestamp: 1,
lastHash : '-----',
hash :'hash-one',
difficulty: INITIAL_DIFFICULTY,
nonce: 0,
data: []
};

module.exports = { GENESIS_DATA} ;

Then in the blockchain file, we updated according to the new values as well:

static isValidChain(chain) {
    if(JSON.stringify(chain[0]) !== JSON.stringify(Block.genesis())) {

    return false;
    };

    for (let i=1; i<chain.length; i++){
        const { timestamp, lastHash, hash, nonce, difficulty,data } = chain[i];

        const actualLastHash = chain[i-1].hash;


        if(lastHash !== actualLastHash) return false;

        const validatedHash = cryptoHash(timestamp, lastHash, data, nonce, difficulty);

        if(hash !== validatedHash) return false;
    }

    return true;
}

}

We also updated the minedBlock fucntion like so:

static mineBlock({ lastBlock, data }) {
let hash, timestamp;
const lastHash = lastBlock.hash;
const { difficulty } = lastBlock;
let nonce = 0;

    do {
        nonce++;
        timestamp = Date.now();
        hash = cryptoHash(timestamp, lastHash, data, nonce, difficulty);
    } while (hash.substring(0, difficulty) !== '0'.repeat(difficulty));

    return new this({ timestamp,lastHash,data,difficulty,nonce,hash });

Next we need to find a way to dynamically change the difficulty of the new blocks on the chain by establishiing a mine rate. So we update out config.js file:

cont MINE_RATE = 1000;

const INITIAL_DIFFICULTY = 3;

const GENESIS_DATA = {
timestamp: 1,
lastHash : '-----',
hash :'hash-one',
difficulty: INITIAL_DIFFICULTY,
nonce: 0,
data: []
};

module.exports = { GENESIS_DATA, MINE_RATE} ;

Afterward we add a tests for asjusting difficulty in block.test.js:
describe('adjustDifficulty()', ()=> {
it('raises the difficulty for a quickly mined block', () =>{
expect(Block.adjustDifficulty({
originalBlock: block, timestamp: block.timestamp + MINE_RATE - 100
})).toEqual(block.difficulty+1);
});

    it('lowers the difficulty for a slowly mined block', () => {
        expect(Block.adjustDifficulty({
            originalBlock: block, timestamp: block.timestamp + MINE_RATE +100
        })).toEqual(block.difficulty-1);
    });
});

});

Here if the block was mined to fast, we increase the difficulty and if mined to long we decrease the difficulty.From here we add the adjustDifficuly() function to our block.js file:

static adjustDifficulty({ originalBlock, timestamp }){
const { difficulty } = originalBlock;

    const difference = timestamp - originalBlock.timestamp;

    if(difference > MINE_RATE) return difficulty -1;

    return difficulty + 1;
}

Next we improve the proof of work system by implementing an average work script.The reason being is that we want to mine blocks with leading zeros in hexeadecimal. So we need to add parameters that will also be able to solve the binary hashes with leading zeros.We going to write a script that takes tha average pace of mining when we try to add meany blocks to the chain.

average-work.js
const Blockchain = require('./blockchain');

const blockchain = new Blockchain();

blockchain.addBlock({data: 'inital'});

let prevTimestamp, nextTimestamp, nextBlock, timeDiff,average;

const times = [];

for(let i=0; i<10000; i++){
prevTimestamp = blockchain.chain[blockchain.chain.length-1].timestamp;

blockchain.addBlock({ data: `block ${i}`});
nextBlock = blockchain.chain[blockchain.chain.length-1];

nextTimestamp = nextBlock.timestamp;
timeDiff = nextTimestamp - prevTimestamp;
times.push(timeDiff);

average = times.reduce((total, num) => (total + num))/times.length;

console.log(`Time to mine block: ${timeDiff}ms.Difficulty: ${nextBlock}.Average time: ${average}ms`)

}

Here we've initiated a new instance of a block for our average work script. This way, the new block's timestamp will be different from the genesis data's timetamp and we keep track of times in a times array.Finally we ensure that the difficulty cannot be abritrarily changed by adding a description for a jumped block.
blockchain.test.js:

const cryptoHash = require('./crypto-hash');

describe('and the chain contains a block with a jumped difficulty', () => {
it('return false', () => {
const lastBlock = blockchain.chain[blockchain.chain.length-1];
const lastHash = lastBlock.hash;
const timestamp = Date.now();
const nonce = 0;
const data = [];
const difficulty = lastBlock.difficulty - 3;
const hash = cryptoHash(timestamp, lastHash, difficulty, nonce, data);
const badBlock = new Block({
timestamp, lastHash, hash, nonce, data

                    });
                    blockchain.chain.push(badBlock);

                    expect(Blockchain.isValidChain(blockchain.chain).toBe(false));
                });
            });

And we finally update the isValidChain in blockchain.js:
static isValidChain(chain) {
if(JSON.stringify(chain[0]) !== JSON.stringify(Block.genesis())) {

    return false;
    };

    for (let i=1; i<chain.length; i++){
        const { timestamp, lastHash, hash, nonce, difficulty,data } = chain[i];
        const actualLastHash = chain[i-1].hash;
        const lastDifficulty = chain[i-1].difficulty;

        if(lastHash !== actualLastHash) return false;

        const validatedHash = cryptoHash(timestamp, lastHash, data, nonce, difficulty);

        if(hash !== validatedHash) return false;

        if(Math.abs(lastDifficulty - difficulty) > 1) return false 
    }

    return true;
}

Personal reflection:
This took me a week longer to implement and follow along because the tests for error checking wasn't working. I finally got feed back from the coures instructor and it turns out that I hadn't properly nested the beforeEach block in the blockchain test file. While refactoring some code and checking the difference, I can get the test checking properly it seems.

Still at this part of the course we've completed the block and test needed to work on the blockchain network. Before moving onto the API and Network implementation I'll review everything I've done up to this point. I'm getting more comfortable with porject but need to take it one section at a time. I've already statred thinking about how this could be implemented in future cloud infrastructure but for now just relax, review and get ready for the next section.

Thanks for reading :)

MY Journey Through Tech:Fullstack Blockchain Course Section 2

Jonathan Thomas — Sun, 16 Feb 2020 12:26:45 +0000

In the last post here, we managed to create a block object with hashing functionality. We also identified the tests that must be passed for valid blocks. Today, we are adding the blockchain.test.js and blockchain.js as such:

Adding the blockchain.test.js:

const Blockchain = require('./blockchain');
const Block = require('./block');

describe('Blockchain', () => {
const blockchain = new Blockchain();

ii('contains a `chain` Array instance', () => {
    expect(blockchain.chain instanceof Array).toBe(true);

});
it('starts with the genesis block', () =>{
    expect(blockchain.chain[0]).toEqual(Block.genesis());
});
it('adds a new block to the chain', () =>{
    const newData = 'foo-bar';
    blockchain.addBlock({data : newData });

    expect(blockchain.chain[blockchain.chain.length-1].data).toEqual(newData);

});

})

In this test we import the blockchain.js and block.js files for the program. Next in our description for the test, we're expecting the object values to be start with a genesis block as the first item in the array.Then is looks for the addBlock method in the blockchain file as an instance of a block itself and calling the "{data:newData}" object does this as arguments for the addBlock function. Then finally we expect the most recent value to be the last item in the chain.

Add blockchain.js:

const Block = require('./block');
class Blockchain{
constructor(){
this.chain = [Block.genesis()];
}

addBlock({ data }){
    const newBlock = Block.mineBlock({
        lastBlock: this.chain[this.chain.length-1],
        data
    });

    this.chain.push(newBlock);
}

}

module.exports = Blockchain;

Here we created the blockchain class by importing the block.js file. In the constructor, we declared a genesis block is the first item in the array. Then we created the addBlock method that takes a data object as an argument. You'll recall that the mineBlock method has data as it's own argument from the block.js file when creating an instance. It then looks for the last item in the array and pushes it into the blockchain array as a data value. Finally to be seen for the tests, we export it it locally.

Completing the Chain Validation tests

To complete our blockchain.test file we now refactor it as show:

const Blockchain = require('./blockchain');
const Block = require('./block');

describe('Blockchain', () => {
let blockchain;

beforeEach( () => {
    blockchain = new Blockchain();
});

it('contains a `chain` Array instance', () => {
    expect(blockchain.chain instanceof Array).toBe(true);

});
it('starts with the genesis block', () =>{
    expect(blockchain.chain[0]).toEqual(Block.genesis());
});
it('adds a new block to the chain', () =>{
    const newData = 'foo-bar';
    blockchain.addBlock({data : newData });

    expect(blockchain.chain[blockchain.chain.length-1].data).toEqual(newData);

});

describe('isValidChain()', () => {
    describe('when the chain does not start with a genesis block', () =>{
        it('returns false', () => {
            blockchain.chain[0] = { data: 'fake-genesis'};

            expect(Blockchain.isValidChain(blockchain.chain)).toBe(false);
        });

    });

        describe('when the chain starts with the genesis block and has multiple blocks', () => {
            beforeEach( () => {
                blockchain.addBlock({ data: 'Bears'});
                blockchain.addBlock({data: 'Beets'});
                blockchain.addBlock({data: 'Battlestar Galactica' });

            });
            describe('and lastHash reference has changed', () =>{
                it('returns false', () => {


                    blockchain.chain[2].lastHash = 'broken-lastHash';

                    expect(blockchain.isValidChain(blockchain.chain)).toBe(false);
                });
            });

            describe('when the chain starts with the genesis block and has multiple blocks', () => {
                describe('and a lastHash reference has changed', () => {
                    it('returns false', () => {});
                });

                describe('and the chain contains a block with an invalid field', () => {
                    it('returns false', () => {

                        blockchain.chain[2].data = 'some-bad-and-evil-data';

                        expect(blockchain.isValidChain(blockchain.chain)).toBe(false);
                    });
                });

                describe('and the chain does not contain any invalid blocks', () => {
                    it('returns true', () => {

                        expect(blockchain.isValidChain(blockchain.chain)).toBe(true);

                    });
                });
            });

        });
    });
});

});

Immediately in the first describe block, we change it so that there is a new block is formed every time using the beforeEach function. We then added out validation test to see if the data matches the arguments needed before adding the a new block to the chain.Again we also used beforeEach within the multiple block tests with dummy data.

Chain Validation code//blockchain.js

static isValidChain(chain) {
if(JSON.stringify(chain[0]) !== JSON.stringify(Block.genesis())) {

    return false;
    };

    for (let i=1; i<chain.length; i++){
        const { timestamp, lastHash, hash, data } = chain[i];

        const actualLastHash = chain[i-1].hash;


        if(lastHash !== actualLastHash) return false;

        const validatedHash = cryptoHash(timestamp, lastHash, data);

        if(hash !== validatedHash) return false;
    }

    return true;
}

Here, we've completed the is valid chain function.Since the instance of a block object can be called in the blockchain test we use the JSON.stringify method so that the data inside the block can be read for testing.We iterate through the data of the block instance that get pushed into an arry. It checks the hash of the last block is valid before continuing on to chain replacement.

Chain replacement tests:

describe('replaceChain()', () => {
    describe('when the new chain is not longer', () => {
        it('does not replace the chain', () => {
            newChain.chain[0] = { new : 'chain' };

            blockchain.replaceChain(newChain.chain);

            expect(blockchain.chain).toEqual(originalChain);
        });

        describe('when the chain is longer', () => {
            beforeEach(() => {
                newChain.addBlock({ data: 'Bears'});
                newChain.addBlock({data: 'Beets'});
                newChain.addBlock({data: 'Battlestar Galactica' });
            });

            describe('and the chain is invalid', () => {});
                it('does not replace the chain', () => {
                    newChain.chain[2].hash = 'some-fake-hash';

                    blockchain.replaceChain(newChain.chain);

                    expect(blockchain.chain).toEqual(originalChain);

                });
            describe('and the chain is valid', () => {
                it('replaces the chain', () => {
                    blockchain.replaceChain(newChain.chain);

                    expect(blockchain.chain).toEqual(newChain.chain);
                });
            });
        });
    });
})

In completing the tests for chain replacement, we check to see if the chain length matches what needs to be taken.If the chain length doesn't match up, it creates a new instance at the end of the array.In the next description, we check if the chain is longer but populated with invalid data, it doesn't replace the last block, rather, it calls the replaceChain function to make a new instance of a valid block.

Chain replacement function

replaceChain(chain) {
if(chain.length <= this.chain.length){
return;
}
if(!Blockchain.isValidChain(chain)){
return;
}
this.chain = chain;
}
Finally we add the replaceChain functionality anf having our tests pass.

Personal Reflections:
It took a bit longer to complete this section. So far I'm averaging a section a week and I'm probably going to stick to that schedule. I'm also in the third week of the IT Analyst program and I'm well on my way to being read for the Comptia Core 1 Exam in 3 weeks time.Wrting the test decriptions was abit confusing, but ultimately made sense with practice. All that's left now is to add stubs for error checking and I can move on to the next section.

Thanks for reading and hapy coding, constructive criticism always welcome

My Journey Through Tech:Fullstack Blockchain Course Section 1

Jonathan Thomas — Tue, 11 Feb 2020 13:04:34 +0000

As I'm progressing well with my A+ certification course, I believe now is a good get back into coding again. By learning the blockchain development, it'll reinforce what I've learned as I follow along and summarize what I do with each section completed.

First I updated node and npm using nvm. Using nvm I don't have to worry about versions not matching and can actually focus on the project itself.

I also managed to download a stable redis server that for later in the course. I'll be building this in the Ubuntu box.

Next I downloaded the jest library as a dependency and saved it. I confirmed this by checking the package.json file.

I then created the block class using javascript OOP syntax
The constructor arguments include a timestamp, lastHash, hash and data. In an effort to avoid errors such as arguments not being put in order, wrapped the arguments as an object.

So our initial block class looks like this now:

class Block{
constructor({timestamp, lastHash, hash, data}){
this.timestamp = timestamp;
this.lastHash = lastHash;
this.hash = hash;
this.data = data;
}
}

module.exports = Block;

Moving on, we were then to use test driven development methodology by adding the jest script to the package json file watching for errors. We then had to created a test file with the following code:

const Block = require("./block");

describe('Block',() => {
const timestamp = 'a-date';
const lastHash = 'foo-hash';
const hash = 'bar-hash';
const data = ['blockchain', 'data'];
const block = new Block({timestamp,lastHash,hash, data});

it("has a timestamp, lastHash, hash and data property", () => {
    expect(block.timestamp).toEqual(timestamp);
    expect(block.lastHash).toEqual(lastHash);
    expect(block.hash).toEqual(hash);
    expect(block.data).toEqual(data);
});

});

This code states that the block.js file in the same directory will be looked at first to see if it exists. Then using the describe keywork, we set the arguments used in the block constructor from block.js by declaring them as variables in the describe object. The 'it' keyword then uses an anonymous function expecting the arguments of the block class to be found using the toEqual method as a form of testing.

To add more functionality, we created a genesis data that could populate the first block in the chain in a config.js file with the following code:

const GENESIS_DATA = {
timestamp: 1,
lastHash : '-----',
hash :'hash-one',
data: []
};
module.exports = { GENESIS_DATA} ;

Here, we created dummy data that could be used to populate a block. with that in mind we had to require this code in the block.test.js file and the block.js file as such:

const { GENESIS_DATA } = require('./config')

Futher we also had to make sure the instances of the genesis block could be generated during the test by adding the following in the block.test.js file:

describe('genesis()', () => {
//calls instance of genesis blocks this is a static function :)
const genesisBlock = Block.genesis();
console.log('genesisBlock', genesisBlock);

    it('returns a Block instance', () => {
        expect(genesisBlock instanceof Block).toBe(true);
    });

    it('returns the genesis data', () =>{
        expect(genesisBlock).toEqual(GENESIS_DATA);
    });
});

In this describe object, we added we're creating a new instance of a genesis block and checking if it meets the required arguments. Upon testing, an error occurs because we did not define the genesis block as a function inside the block.js file. To remedy and pass the test, we simply add the genesis function to the Clock class like so:

static genesis() {
return new this(GENESIS_DATA);
}

Since we've imported the "{ GENESIS_DATA }" from the config.js file we can now properly create instances of a genesis block.Next within out block.test.js file, we wanted to add the mine Block description like this:

describe('mineBlock()', () =>{
const lastBlock = Block.genesis();
const data = 'mined data';
const minedBlock = Block.mineBlock({ lastBlock, data });

    it('returns a Block instace', () => {
        expect(minedBlock instanceof Block).toBe(true);
    });

    it('sets the `lastHash` to be the `hash` of the lastBlock', () => {
        expect(mineBlock.lastHash).toEqual(lastBlock.hash);
    });

    it('sets the `data`', () => {
        expect(minedBlock.data).toEqual(data);
    });
    it('sets a `timestap`', () => {
        expect(minedBlock.timestamp).not.toEqual(undefined);
    });
});

Here we're testing if the lastHash to be the hash of the previous block, the data of the current block is being mined and the timestamp matches.

Afterwards we added mine block method to the block.js file so that the instances of mineBlock can be generated like so:

static mineBlock({ lastBlock, data }) {
    return new this({
        timestamp: Date.now(),
        lastHash: lastBlock.hash,
        data
    });
}

Now that we've established the block functionality, we need to add hashes to be checked using SHA 256. First we created a crypto-hash.js and crypto-hashe.test.js files respectively:

//crypto-hash.js
const crypto = require('crypto');
const cryptoHash = (...inputs) => {
const hash = crypto.createHash('sha256');

hash.update(inputs.sort().join(' '));

return hash.digest('hex');

};

module.exports = cryptoHash;
In the cyrpto-hash file, we import and require the 'crypto' module of NodeJS. When we declare the cryptoHash, we use the spread operator on the data within the upcoming 'inputs array'. Then we use the update, sort and joint methods to format the hashes from the last block and returns them as a hexadecimal value using the digest built in. This ensures that there will at least be some hasing present regardless of argument orders.

//crypto-hash.test.js

const cryptoHash = require('./crypto-hash');

describe('cryptoHash', () => {

it('generates SHA-256 hashed output', () =>{
    expect(cryptoHash('foo'))   .toEqual('2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae');
});

it('produces the same hash with the same input in any order', () =>{
    expect(cryptoHash('one', 'two','three'))
    .toEqaul(cryptoHash('three','one','two'));
});

});
In the testing file, we got the hash of 'foo' and test to see if it matches up. Furthermore, we now have to update our block/block.test functions respectufully by importing the crypto-hash files from the local directory:
//added to block.js, block.test.js
const cryptoHash = require("./crypto-hash");

Then we updated the mineBlock function to a more completed state like this:
//block.js
static mineBlock({ lastBlock, data }) {

    const timestamp = Date.now();
    const lastHash = lastBlock.hash;

    return new this({
        timestamp,
        lastHash,
        data,
        hash: cryptoHash(timestamp, lastHash, data)
    });
}

Now that we've declared the timestamp,lastHash and data in the cryptoHash module new instances apply a hash to the arguments of the block. We also finalized the mineBlock description test as so:

//block.test.js
describe('mineBlock()', () =>{
const lastBlock = Block.genesis();
const data = 'mined data';
const minedBlock = Block.mineBlock({ lastBlock, data });

    it('returns a Block instace', () => {
        expect(minedBlock instanceof Block).toBe(true);
    });

    it('sets the `lastHash` to be the `hash` of the lastBlock', () => {
        expect(minedBlock.lastHash).toEqual(lastBlock.hash);
    });

    it('sets the `data`', () => {
        expect(minedBlock.data).toEqual(data);
    });
    it('sets a `timestap`', () => {
        expect(minedBlock.timestamp).not.toEqual(undefined);
    });
    it('creates a sha-256 `hash` based on proper inputs', () => {
        expect(minedBlock.hash).toEqual(cryptoHash(minedBlock.timestamp, lastBlock.hash, data));
    });
});

So in summary, I've created a block, started using a test driven development approach, added functionality to the blocks and I'm now ready to move on to the next section.

Personal reflection: This is the most coding I've done in the last 3 months. It feels really good to understand what I'm doing. I've really reinforced object oriented programming concepts in javascript, the use of anonymous functions and was introduced to a new way of developing a project. I fins it also helps that iI actually record what it is I've done after I complete each section. For now I'm off to study the A+ materials for today and will start section 2 of this course in the morning.

Things to keep in mind: There are some portions of javascript I should really become more familiar like spread operators. As such it's probably a good idea to keep up with the documentaion. I should also change my git settings so I can push requests faster, but that's another story.
Anyway that was my the summary of Section 1, constructive criticism is alsways welsom and have a nice day!

My new pathway into tech: Junior IT Analyst bootcamp through NPowerCanada

Jonathan Thomas — Thu, 30 Jan 2020 04:13:44 +0000

In July 2019, my father was diagnosed with cancer. Today I am happy to say that treatment has been effective and he is in remission as of writing.

That said I've never been more relieved and thank the people who posted here for pathways and projects they suggested.

Unfortunately, I wasn't able to land a developer job. I still had to take odd jobs to help my family until I was laid off in October. Since then I haven't even so much opened an text editor. I think it's because I've been trying to learn web development as a prerequisite for everything else. I still like coding but I kept getting caught up in trying to build projects from scratch and be unique.

That approach is why I never progressed. So for now I'll have to take a different approach and pause the coveted developer pathway. Because I realise it's not where I need to be...yet.

But all those courses and groups weren't in vain because it revealed my true interest and career fit Information Technology.

I realise now that I've been idealizing the creative portion of tech as a substitute for not being able to create art. After actually reflecting on all the skills that I attempted to learn,I came up with career and creative goals. Creative wise, I know I want to make comics and YouTube videos and planned out the year for that.

Career wise,I am actually interested in the operation and analysis of all things technology related.Now that I manage to seperate the two I shifted my focus to entry level IT support roles or training. I had already completed Google Information Support Specialization from Coursera in 2018. But that wasn't enough so I had to dig deeper into the skills I had tried and liked as a hobbies.

Before that I was(am)a member of Cybrary.it and went through the various modules of Comptia, Cisco and Microsoft theory that would prepare me for certification.I dabble with some network security and penetration testing from a membership at StationX

I always thought it would be nice to have certs, but never found a training/testing that wouldn't be ridiculously marked up by for profit institutions. That changed however when I was reached out to by a community employment services news letter I had signed up for and I saw it right there in the list:

JUNIOR IT ANALYST BOOTCAMP via NPowerCanada. The site outlined a 14 week ,FREE, bootcamp that would not only prepare me for Comptia A+ certification, cover the COST of the testing, industry networking/scouting and job/support placement. THIS IS EXACTLY WHAT I NEED RIGHT NOW XD!!!!!

I clicked the linked, saw that I met the requirements for the program and applied immediately. This was back in November. Weeks went by then in the middle of December I got to the interview portion. I was honest about my situation and explained everything that I'd done to get into tech on my own. I knew this was my best chance for an actually career if only given a chance.

I was thanked for being honest and open in my interview. I was told accepted candidates would be contacted by early January. I walked out and waited.

Three days later I received a congratulatory email saying I'd been accepted into the program. I finally got my foot in the door moment and in the week since this program has started, it's the first time in nearly a decade that careerwise, felt absolutely right.

Next post will be when we actually start the A+ training

Thanks for reading

Recursion recall, because it's necessary

Jonathan Thomas — Wed, 17 Jul 2019 20:10:48 +0000

Continuing on since my last post on Big O, which involves time and space complexity of programs, I'm adding a quick recall of an often used, if not completely understood concept. RECURSION!

What it do?

Recursion, in the most basic terms ,is a function that has the ability to call itself.It is used all the time in in programming and is seen as a cleaner alternative to iteration.

With recursion, you use a different input each time until you reach your base case.

For example, you have an array of numbers and you want to find out which of the elements are odd. So knowing that even numbers are anything divisible by two with no remainder, I can say my base case is
N%2 where N is an element in the array divided by two with no remainder.

I could put this in a helper function that uses this as the base case when no matter what my inputs. We need a base case and different inputs to ensure that program returns the base case when conditions are met.

So this was my quick recall of recursion. I will come back and post an updated version as I learn more. Constructive criticism is greatly appreciated and hopefully this helps you too.

Thanks for reading.....k bye :)

My recall of Big O and how understanding it will make all development easier.

Jonathan Thomas — Fri, 12 Jul 2019 20:22:36 +0000

Since my last post I've been working on and off getting back into the flow of code.

Recently I dived back into Data Structures and Algorithms in Javascript Masterclass by Colt Steele. So far the concepts are starting to make sense but to really reinfore the ideas recall is needed so here it goes

In computer science, Big O is a measurment used to describe the efficiency of algorithms. There are best, worse and average cases that can come about depending on the data structures, algorithms and languages used.

Common runtimes include O(N), O(log N), O(N log N), O(N^2) and O(2^N).

Runtimes are determined by the amount of operations and memory(O(1) a constant as an example) used in programming.

Ideally taking runtimes into account could help when deploying a program. In thes case of javascript in browsers, depending on the browsers themeselves, different runtimes might occur.

With regard to memory(O(1)), also know as space complexity, can affect big O since the computer has to reserve memeory to use for operations.

Best and worst case scenarios are determined by what the algorithm is trying to do. For example of going through an array of near sorted items for bubble sort would be O(N) however in most cases the items will have to be sorted first, thus we'd be left with O(N^2) since it has to recursively go through and check each element that isn't sorted.

Anyway this was my first foray into inderstanding big O theory and constructive criticism and guidance os greatly appreciated.

If there is anything that I'm missing or could elaborate on, please let me know.

Thanks again,
Jonathan Thomas, future Software Engineer

I NEED mentorship to land a job within the next 120 days becaue my father is dying...

Jonathan Thomas — Sun, 07 Jul 2019 03:01:14 +0000

Hey all, so very new to this communtiy and, kind of at a loss. I've been putting off trying to land a developer career because life keeps getting in the way. Well, today the biggest obstacle to this journey has just been put in front of me. This morning at 11:15 am, my father was diagnosed with cancer of the lungs, liver and colon. The shock and sadness are still prevalent, I'm hurting, my mother and brother are hurting. I'm sad and angry because even all three of our jobs right now won't enough. So I need build my portfolio starting right now.

I need to get one of these jobs but I don't know what to build to even get my foot in the door. I've been putting it off over and over again, but this is my wake up call. I have to land a job in the next 4 months(projection from doctors).So I reach out to you those who are already in tech for guidance and what to add. I'll link my github and linkedin profiles here, I just don't know how to focus. Please, any advice or guidance would be greatly appreciated as I take things one day at a time.I have to make this work for my family's sake

github: https://github.com/JonathanMKPT
linkedin: https://www.linkedin.com/in/jonathan-thomas-5b5135114

Thanks in advance,
Jonathan Thomas

Is it possible to suffer from code withdrawal?

Jonathan Thomas — Thu, 04 Jul 2019 17:58:40 +0000

I ask this because as I sit in another industrial mechanic theory class I'm zoning out thinking about all the programming I could be learning now.

I kind of feel weak and stressed that I'm not at a terminal right now. Especially after I'll be going straight to work after my classes and that means I'll be away longer.

The keyboard is calling and I'm not there, does anyone have advice for this type of experience?

Thanks in advance

Coding procrastination keeps me back and my plan to handle the future

Jonathan Thomas — Thu, 27 Jun 2019 14:08:28 +0000

It's been two months since my last bootcamp. Let the coding procastination begin! Sadly, I am no closer to the goal I set forth to complete by August 1st, 2019. From this previous post, I made my intention clear that I would do everything it took to finally land a coveted tech job. Yet now I find myself in a government funded skilled trades program. While I'm grateful for the opportunity and tactile experiences, I feel my bias against this employ remain still. The program and text books are free so it's soemthing different, but I don't see any longer term career out of this. For now, I'll stick it out and continue to work on ways to get back into the software development habit.

But to make that habit successful, I need to understand how I get distracted from coding when life opportunities occur.

For the full post please click here. Have a wonderful day!
http://afropolymath.com/procastination-sucks-ass-when-your-broke/