DEV Community: Steve Latham

Advent of Code (AoC) - Day 1

Steve Latham — Mon, 02 Dec 2019 11:36:56 +0000

I thought I'd document my journey through AoC 2019. As I've been concentrating on learning React recently, I feel like some other basic concepts might be starting to fade from my memory banks!

Part one was very straight forward.

Read in the input numbers from the text file and stuff them into the calculation given to you: -

const readline = require('readline');
const fs = require('fs');

// set up the file for reading line-by-line
const readInterface = readline.createInterface({
    input: fs.createReadStream('./AoC1-input.txt')
});

// calculate fuel required given a mass
const getFuelRequirement = (mass) => {
    return fuel = Math.floor((mass / 3) - 2)
}

// calculate the total fuel requirement
// for all the masses listed in the file
const getTotalFuelRequirement = () => {
    let totalFuel = 0; 
    // on each new line, add the calculated requirement to
    // the totalFuel
    readInterface.on('line', (line) => {
        totalFuel += getFuelRequirement(line)
    });

    // at the end console log the total
    readInterface.on('close', () => {
        console.log(totalFuel)
    })
}

getTotalFuelRequirement()

Then, the spanner in the works for me came on part two. I think it was hinting at solving the problem with a recursive function. I was scrambling trying to get my brain into that mode of using recursion. I almost gave up, reverting to a solution without the recursive bit, but the reason I am doing this is to try to help me remember some concepts I'd let slip. So I persevered and came up with a solution: -

const readline = require('readline');
const fs = require('fs');

// set up the file for reading line-by-line
const readInterface = readline.createInterface({
    input: fs.createReadStream('./AoC1-input.txt'),
});

// calculate fuel required given a mass
const getFuelRequirement = (mass) => {

    let fuel = Math.floor((mass / 3) - 2)

    // base case -- fuel required is negative or zero
    if(fuel <= 0){
        return 0;
    }
    // recursive bit - fuel for the initial mass, plus the
    // fuel required for the fuel until it is zero
    return fuel + getFuelRequirement(fuel);

}

const getTotalFuelRequirement = () => {
    let totalFuel = 0; 
    readInterface.on('line', (line) => {
        totalFuel += getFuelRequirement(line)
    });
    readInterface.on('close', () => {
        console.log(totalFuel)
    })
}

getTotalFuelRequirement()

My first PR

Steve Latham — Wed, 02 Oct 2019 10:45:13 +0000

I've finally made my first ever contribution to an open-source project. I did it because it is something I've always wanted to start doing and never done, but this month mainly for the Hacktoberfest t-shirt!

It was an issue flagged on the Strapi GitHub page. I picked it because I might be using Strapi in an upcoming project, and more importantly, it looked easy to tackle but wasn't something as trivial as a documentation fix. Best of all, the PR was accepted and merged the same day by none other than Strapi's co-founder. I've made it! Watch out, Linus! If anyone needs a single word on a single line of code changing, I'm your man.

If you're struggling to find a good first Hacktoberfest PR like I was, I'd recommend choosing a project that has good concise documentation and a guide on how you can set up your development environment to get started. Also, something you've used or know in some capacity. While searching and looking at the "Good first issue" tags I found myself being sidetracked trying to work out what the project actually did or looked like. I'd then get bored and move onto the next project.

I'm a procrastinator of epic proportions, so it felt good to actually do something! Now onto the next three issues...

Just passing by

Steve Latham — Mon, 25 Feb 2019 15:39:15 +0000

This is a note-to-self and any other passers-by.

By Value

Follow the below example...


let a = 42;    // define variable "a" as 42
let b = a;     // define b to be equal to a

// log out the results
console.log(a);    // => 42
console.log(b);    // => 42 

// now if we give b the value of 100
b = 100;

// log out the results again
console.log(a);    // => 42
console.log(b);    // => 100

The point to remember is that when we assign "b" to equal "a" on line 2, what happens is the value (42 in this case) stored in "a" is copied to "b". It is said to be passed by value.

When we eventually give "b" another value (100 in this example), it has no effect on the variable "a". We can see "a" is still 42 and "b" has now changed to 100.

By Reference

Now consider this familiar(ish) example...


let a = {value: 42};    // define variable "a" to be an object
let b = a;              // define b to be equal to a

// log out the results
console.log(a);    // => {value: 42}
console.log(b);    // => {value: 42} 

// now if we change a property of b
b.value = 100;

// log out the results again
console.log(a);    // => {value: 100}
console.log(b);    // => {value: 100}

The point to remember here is when we assign "b" to equal "a" on line 2, what happens is a reference to the value of "a" is passed to "b". Then both "a" and "b" point to the value (in this case the object {value: 42}). They are both just a reference to the object {value: 42} stored in memory. This is demonstrated when we change the value of "b.value" to 100, we see "a" also shows this change.

So what is going on?

Well, it depends on the value that is stored in the variable. If you are dealing with a primitive type - say a number or a string as in the first example, then pass by value is used. For objects and arrays, on the other hand, pass by reference is used.

To boil it down: If you pass an array or an object to a variable or a function, you are just passing a reference to it.

So if we look at the following example and read through the code...

// define a function that takes two parameters
const myFunction = (x,y) => {

  x[3] = 42;    // change the 4th array element to 42
  y = 100;     // change y to equal 100  

}

let a = [1,2,3,4];    // define a to be an array
let b = 42;           // define b to be the number 42
myFunction(a,b);      // call the function with a and b as the arguments

// log out the result on a and b of calling the function
console.log(a);    // => [1,2,3,42]     
console.log(b);    // => 42

We can see that "a" is mutated by the function, but "b" is not. The primitive number 42 is passed to the function by value. So "y" is a copy of "b", then "y" gets changed to 100 leaving "b" unchanged.

On the other hand, the reference to the array "a" is passed to the function, the array is then mutated as "x" and "a" are just pointers to the original array.

Clear as mud!

Bash! Bash! Bang! Bang!

Steve Latham — Thu, 07 Feb 2019 12:22:55 +0000

The Bang Bang (!!)

What is the Bang Bang? Typing two exclamation points into your command-line and hitting your enter key with as much force as you can muster.

!! = Play the last command again, Sam.

Example:

Say you are installing an npm package globally (as you do): -

npm install -g <package_name>

Only to receive lots of permission denied errors. That’s right, you’ve forgotten to use “sudo” again, haven’t you!

You could press the up arrow and then navigate to the start of the line and type “sudo”, hit space and then meekly press the enter key.

Instead, though, you can roll out the almighty Bang Bang: -

sudo !!

In our example, that is equivalent to: -

sudo npm install –g <package_name>

You will eventually be using this shortcut everywhere you can.

After travelling to work only to realise you have forgotten your pass, just think -

pick up pass !!

Then, if that doesn't work, deploy the big guns: -

sudo !!

Problem solved.