DEV Community: Samuel Grasse-Haroldsen

Coding Conway's Game of Life in Go

Samuel Grasse-Haroldsen — Mon, 24 May 2021 01:29:38 +0000

Have you heard of Conway's Game of Life? It is a 0 player simulation that is absolutely fascinating to watch. Based on only a few simple rules, we can create a visualization of this simulation and watch it to our heart's content. Here's a cool website where you can experiment with the game and watch what happens: Conway's Game of Life.

The Game

The simulation takes place on a 2D grid. Cells on this grid are either dead or alive. With each iteration of the game, cells live and die based on the rules of the game.

The Rules

A living cell with 2-3 neighbors will continue to live.
A dead cell with exactly 3 neighbors comes to life.

Any other cell will die or stay dead (if it has more than 3 neighbors or less than 2 neighbors).

Requirements

For a 2 dimensional grid we will need an array of arrays to represent each row of cells. Because a cell can only be in one of two states (no quantum funny business here), we will use booleans as the type in our array of arrays. As far as packages go, we will need fmt to print our array, math/rand to generate our initial grid, and time so we can observe each iteration of the game. I will also make use of some unicode characters to make the display of our game a little more visually appealing.

Let's Start!

First we need to make our grid. Let's import the packages we need and define some constants for the dimensions of the grid. You could make these whatever you want, just be aware that it might look strange depending on the size of your terminal.

While we are defining constants, let's go ahead and declare a few more like the Unicode characters to represent dead vs living cells (I'll be using brown and green squares but feel free to use whatever you want), as well as an ANSI escape sequence to clear our screen each iteration (we want the appearance of animation). We'll also declare a sleepIteration const so we can easily change how long each iteration should be displayed (this will be useful when debugging.

Check out this website to search for the UTF-8 codes for different symbols/characters: Unicode

package main

import (
    "fmt"
    "math/rand"
    "time
)

const (
        width          = 40
        height         = 20
        sleepIteration = 100
        ansiEscapeSeq  = "\033c\x0c"   
        brownSquare    = "\xF0\x9F\x9F\xAB"    
        greenSquare    = "\xF0\x9F\x9F\xA9"

)

The Grid

Let's go ahead and make a new type to represent the grid of cells. Feel free to call this whatever makes the most sense to you: world, universe, plane, grid, etc. I know I mentioned arrays earlier, but we will be utilizing slices as they are much more flexible and fun (in my opinion)!

type World [][]bool

Now that we have a type to represent a slice of slices that each hold a boolean value, we can make some methods to go along with our new World type.

World Methods

We will want a few different methods to interact with our World type:

Display: This will be the method responsible for displaying our World
Seed: This will initialize our World with data (we will utilize the rand package in this method)
Alive: This method will return true if the given cell, x y coordinates, is alive and false otherwise
Neighbors: This method will return how many neighbors (alive ones) a given cell has
Next: This method will determine the next state of a given cell

We will also need two functions:

MakeWorld: This will initialize our World type
Step: takes in two Worlds and sets the Next state of one World by reading the current state of the other.

Let's go ahead and go through each function and method.

MakeWorld

func MakeWorld() World {
        w := make(World, height)
        for i := range w {
                w[i] = make([]bool, width)
        }
        return w
}

Our MakeWorld function returns our newly created world. First we are using the make reserved word to create a World type with height number of slices (the number of rows). Then we are looping through each row and setting the row to be a slice containing boolean values of width length (columns).

Seed

func (w World) Seed() {
        for _, row := range w {
                for i := range row {
                        if rand.Intn(4) == 1 {
                                row[i] = true
                        }
                }
        }
}

In our Seed method we are looping through each row and column and setting the cell value to true if the rand.Intn(4) returns 1 (this will set roughly 25% of the cells to alive.

Display

func (w World) Display() {
        for _, row := range w {
                for _, cell := range row {
                        switch {
                        case cell: 
                                fmt.Printf(greenSquare)
                        default:
                                fmt.Printf(brownSquare)
                        }
                }
                fmt.Printf("\n")
        }
}

Again, we are looping though each slice in our slice and displaying a greenSquare if the cell is alive and the brownSqaure if not. We also print a new line at the end of the inner "cell loop" so we can see where each row ends.

Alive

func (w World) Alive(x, y int) bool {
        y = (height + y) % height
        x = (width + x) % width
        return w[y][x]
}

Do you have a good understanding of the modulo operator? The most complicated part of this method is how we are handling negative & out of bounds input. We want our game to wrap so if we send it (-1, -1), we really want to know the value of the end of our grid so (width, height).

Neighbors

func (w World) Neighbors(x, y int) int {
        var neighbors int

        for i := y - 1; i <= y+1; i++ {
                for j := x - 1; j <= x+1; j++ {
                        if i == y && j == x {
                                continue
                        }
                        if w.Alive(j, i) {
                                neighbors++
                        }
                }
        }
        return neighbors
}

We want to check the life status of the 8 surrounding squares. We will check the 3 cells above, the 3 cells below, and the two cells horizontal to the given cell (we don't want to check the given cell itself; thus the first if statement).

It is so important to make sure that we are consistent in our x, y coordinates. I had some serious bugs when initially writing this program based on misuse of width vs height.

func (w World) Next(x, y int) bool {
        n := w.Neighbors(x, y)
        alive := w.Alive(x, y)
        if n < 4 && n > 1 && alive {
                return true
        } else if n == 3 && !alive {
                return true
        } else {
                return false
        }
}

In our Next method we want to get the given cell's life status and number of neighbors. Then using conditionals we implement the game's rules.

Step

func Step(a, b World) {
        for i := 0; i < height; i++ {
                for j := 0; j < width; j++ {
                        b[i][j] = a.Next(j, i)
                }
        }
}

Step takes in two worlds and alters the second world based on each cell's Next status.

main

Now that we have all the methods and functions in place, lets write the game's sequence in main.

func main() {
        fmt.Println(ansiEscapeSeq)
        rand.Seed(time.Now().UTC().UnixNano())
        newWorld := MakeWorld()
        nextWorld := MakeWorld()
        newWorld.Seed()
        for {
                newWorld.Display()
                Step(newWorld, nextWorld)
                newWorld, nextWorld = nextWorld, newWorld
                time.Sleep(sleepIteration * time.Millisecond)
                fmt.Println(ansiEscapeSeq)
        }
}

Let's walk through this one step-by-step.

We clear the screen using our ansiEscapeSeq
We seed our rand number generator (we will get different results every time based on the time of our system)
We create our newWorld and our nextWorld
We seed our newWorld
Now we create an infinite loop (you don't have to but I could seriously watch this simulation for eternity)
We display the newWorld's freshly seeded data
We calculate the nextWorlds value by calling Step
We swap the values of our nextWorld and the newWorld
We wait for sleepIteration number of milliseconds
We clear the screen
Repeat

Conclusion

There you have it! Conway's game of life implemented in Go. Check it out in the Go playground or code it on your own machine! NOTE: The playground times out of the infinite loop.

Recursion

Samuel Grasse-Haroldsen — Mon, 17 May 2021 04:17:44 +0000

Recursion. I remember a time when that word struck fear in my heart. "Why would anyone want to use recursion instead of a loop to solve a problem?" I thought to myself. Due to this being a crux of mine for such a long time, I decided to dive in, do some research, and conquer my fear of overflowing the call stack.

Recursion: 1 part ending conditional, 1 part changing input

The most important two parts of solving a problem recursively are getting the ending conditional correct and changing the input to the recursive function with each additional call. Don't worry if this doesn't make sense. We'll go over a few examples and hopefully you'll see the pattern.

Iteration VS Recursion

It's important to understand that typically you can solve certain problems in two different ways: with recursion or by looping. Looping has always seemed more straightforward to me and maybe that's because it is what is typically taught first. Let's look at an example solved first by looping, and then the same problem solved recursively.

Value in an Array

Let's write a function that takes an array and a value and checks if that value exists in the array. If it does, we will return true, if not, we will return false.

// looping
function includes(array, value) {
    for (val in array) {
        if (val == value) return true;
    }
    return false;
}

This is a very natural feeling solution to me. We loop through each value in the array, checking if the argument passed in matches any of our array's values. If no match is found, we return false.

Now let's look at the same solution but solved through recursion.

// recursion
function includes(array, value) {
    if (arr.length == 0) return false;
    return arr[0] == val || includesNumber(arr.slice(1, arr.length), val);
}

This solution does not seem as natural, to me at least, but it is just as valid as a solution as the previous iterative solution. In this example we can clearly see the two parts of recursive solutions:

If our array is empty we have no reason to continue calling our function and should return false. After all, reaching the end of the array doesn't mean we have found a match. This is our ending conditional.
The next part is slightly less intuitive. We need to check if the beginning or our array is equal to our given value. But we also need to check the rest of the array by calling our includes function, but if we supply the same array, we will just keep checking the first same element and overflow the call stack. Like I stated earlier, we need our input to change. Because we have already checked the first element in the array, we can now call includes again but this time with that first element removed by slicing the array. Now, the next time we call includes we will check the first element of our new slice, which will really be the second element. We use the || operator because we only need to know if one of our calls to includes returns true.

Reverse a String

Next, let's go ahead a solve the age old problem of reversing a string.

function reverseString(str) {
    if (str.length == 1) return str[0];
    return str[str.length - 1] + reverseString(str.slice(0, str.length - 1));
}

Here again we can see the pattern of an ending conditional and changing our input with each call.

If our string has only 1 character we should return it and end the recursion.
Initially we want to return the last character of the string and then add the next last character. To get that next last character we need to call our function again, but this time remove the last character from our string before we call the reverseString function again. We do this over and over again until we reach our ending conditional.

Check if a String is a Palindrome

For our final example, let's write a recursive function that checks if a string is a palindrome.

function isPalindrome(str) {
    if (str.length <= 1) return true;
    return str[0] == str[str.length - 1] && isPalindrome(str.slice(1, str.length - 1));
}

For our ending conditional we are going to return true if we get to a string length of either 0 or 1, because a palindrome with an odd number of characters will have a middle character with no matching character. And if we reach the end of the string, eg. str.length == 0, then we can return true.
For each call we want to check the first and final character of our string and make sure they match. And for our word to be a palindrome we need that expression to return true AND the following calls to be true. Again, with each additional call we want our argument to change. This time we are removing the first and final characters from the string with each call.

Conclusion

Recursion can be confusing, but just take your time with it and solve a few problems in your free time. If something goes wrong, look at the 2 parts. Most likely, the ending conditional is wrong or the input isn't being changed correctly.

Authenticating in Rails

Samuel Grasse-Haroldsen — Mon, 10 May 2021 00:03:30 +0000

If you want users on your web app, you need to be able to authenticate (verify they are who they say they are) and authorize (give the users access to different resources). Thankfully doing this using Rails is a fairly trivial task. In this tutorial we'll go over how to quickly add users and provide authentication on your web site. In Part 2 we'll discuss authorization in Rails.

NOTE: This tutorial assumes some familiarity with the Ruby on Rails framework.

Creating Users

The most basic attributes users require are a username and a password. Sure, you can add email and actual name depending on your needs, but for the sake of simplicity, we're going to keep it simple today. So our first step to adding users to our Rails app will be creating a new db migration and model.

rails g model user username:string password_digest:string

This will give us a new table called users with two columns: username and password_digest. Both of these columns will contain strings. Make sure to run rails db:migrate after generating your user model.

You might be wondering why we called our password column password_digest and not just password. That is because we will not be storing our users' passwords. That would be a horrible idea for many reasons. Instead, we will be storing a string that is determined by sending our users' password through a complicated algorithm that spits out some garbled text. Although this text is garbled, it is consistently garbled by our rails server, so every time a user signs in, we:

Receive their password
Send it through the algorithm
Compare the garbled output of the algorithm with our stored garbled output (password_digest)
If they match, boom! The user is authenticated!

We'll go over authentication in more depth in the next tutorial.

The bcrypt gem & User model

We will be taking advantage of the bcrypt gem. Make sure you include this in your Gemfile and check out the GitHub if you want to learn more about the process of garbling a password (hashing and salting).

gem 'bcrypt'

Thankfully ActiveModel::SecurePassword is included by default with Rails version >= 3. This means less code! Yay! All we have to do to take advantage of the gem is include this line in our user model file.

class User < ApplicationRecord
  # this is the line I'm talking about
  has_secure_password

  # but these lines are probably a good idea too
  validates :username, uniqueness: true
  validates :username, presence: true
end

We are telling rails to store our users' passwords in their garbled form among other things. The other two lines I included are validations which I'm assuming are fairly intuitive (thanks Ruby & Rails teams) but more here if you are interested: Active Record Validations.

Signing Up

Signing up here means creating a user. Let's create a user!

The Controller

We will need a controller to tell our application which actions to take depending on where the user is. Let's add a users_controller with this command:

rails g controller users

Now for the body let's add some actions (AKA methods).

class UsersController < ApplicationController
  # this creates a "blank user instance for our form"
  def new
    @user = User.new
  end

 def create
    # create a user instance with the username and password params
    @user = User.new(user_params)

    # if it successfully saves to the db
    if @user.save
      # send the user to their homepage (show view)
      redirect_to @user
    else
      # if user doesn't save, render the new view 
      render 'new'
    end
  end

  def show
    set_user
  end

  private
  def set_user
    @user = User.find_by(id: params[:id])
  end

  def user_params
    params.require(:user).permit(:username, :password)
  end

end

The Views

The next step in the process is adding our front-end signup form. When we ran rails g controller users, a users directory was created in our views directory. Let's add a file called new.html.erb. We will need an input field for our user's dream username and another for their password:

<%= form_with(model: @user, local: true, url: '/signup', method: :post) do |f| %>
  <%= f.text_field :username, placeholder: "username"%>
  <%= f.password_field :password, placeholder: "password"%>
  <%= f.submit "Sign Up" %>
<% end %>

Again, thanks to Rails, we have access to something to make our markup a little simpler to right -- form helpers! Now our form can take advantage of our model and we can even add error handling soon.

While we're adding this new user view, let's go ahead and add a show.html.erb, so our user can be greeted once they signup for their new account.

<h1>Welcome <%= @user.username %></h1>

Routing

We haven't set up any routes yet so lets go ahead and do that next.

  get '/signup', to: 'users#new'
  post '/signup', to: 'users#create'
  resources :users, only: [:show]

I've shown a few different ways to add routes here, but you will want to read the Rails docs for routing for more information on good practices and possibilities.

QUICK TIP: You can check out the routes of a rails app by running rails routes.

Testing

Let's go ahead and fire up the rails server with rails s and head over to localhost:3000/signup. We should see a form. Go ahead and test it out with a username and password. You should be greeted! Next week we'll go over how to get our application to remember us (sessions) and allow us to access various resources (authorization).

Using Objects to Count Frequency

Samuel Grasse-Haroldsen — Sun, 02 May 2021 23:33:17 +0000

I've been doing a course on data structures and algorithms and I've noticed a pattern of using objects in JavaScript to count the frequency of values in strings and arrays.

Why use an Object

When talking about algorithms or data structures it is important to understand Big-O notation. I won't go to into detail on what that entails, but for this article we will briefly look at objects and how fast it is to add/access a key-value pair. It is important to note that while objects and maps in JavaScript are similar enough for our purposes, there are some subtle differences relevant stackoverflow article. I will just refer to these types of data structures as objects in this article.

Object Time Complexity

Action	Time Complexity
Insert	O(1) : Constant
Remove	O(1) : Constant
Access	O(1) : Constant
Search	O(N) : Linear

As we can see from our table, objects are very fast at inserting, removing, and accessing key-value pairs. Note: It is is important to note that accessing an element in an array takes constant time ex. names[0] is just as fast as names.sam. The difference is that we can immediately see if there is a key called "sam" in our names object as opposed to something like names.indexOf("sam") which loops over the entire array (linear time). If this doesn't make sense, check out this video Introduction to Big O Notation and Time Complexity.

The Problem

So now that we know that objects are faster than arrays to check if a certain value(the key) exists, let's look at a problem.

Determine if two words are anagrams of each other

Note: an anagram is a word or phrase formed by rearranging the letters of another word or phrase.

The Solution

While there are almost always multiple ways to solve a problem in computer science, let's go ahead and use an object to count the frequency of each character in our strings.

const isAnagram = (str1, str2) => {
  if (str1.length !== str2.length) {
    return false;
  }

  let freqCounter1 = {};
  let freqCounter2 = {};

  for (let char of str1) {
    freqCounter1[char] = (freqCounter1[char] || 0) + 1;
  }
  for (let char of str2) {
    freqCounter2[char] = (freqCounter2[char] || 0) + 1;
  }

  for (let key in freqCounter1) {
    if (freqCounter1[key] !== freqCounter2[key]) {
      return false;
    }
  }
  return true;
};

Let's go over the code line by line.

1. if (str1.length !== str2.length) {

Here we are just short-circuiting our function to return false if the lengths of the strings don't match up.

2. let freqCounter1 = {};

Declaring our frequency counting objects.

3. for (let char of str1) {

Looping through each character of our first string. (Time complexity is linear)

4. freqCounter1[char] = (freqCounter1[char] || 0) + 1;

This is where we are actually adding each character to the frequency counter object and initially setting the value to 0+1. If our character key already exists then its value is added to 1 (incremented). We do the same for our second string.

5. for (let key in freqCounter1) {

Looping through the keys in our frequency counter object. (Read more about the difference between of and in when looping through arrays and objects at stackoverflow)

6. if (freqCounter1[key] !== freqCounter2[key]) {

Here we are checking the frequencies for each character and returning false if they don't match.

Conclusion

Using objects, maps, hashes, dictionaries, or whatever your favorite language calls these data structures as a frequency counter should always be an option you are aware of. It doesn't work for every problem, but it can sometime provide the most optimal solution (2 sum problem, I'm looking at you). Review some problems and see where you can use key-value pairs.

Arrays & Slices

Samuel Grasse-Haroldsen — Mon, 26 Apr 2021 03:42:19 +0000

Arrays in Go

Arrays: one of the most fundamental data structures in computer science. An array is a collection of elements identifiable by an index. In Go that index begins at 0, not 1. Go arrays are limited to hold one type of data and cannot be resized. The array's length is part of it's type and cannot be changed. Another important aspect of arrays in Go is the fact they are passed by value, meaning they cannot be modified if passed to other functions. This may sound very limiting, but Go also has a data structure called a slice which adds functionality to Go arrays. We'll talk about slices in this article, but first the fundamentals!

Declaring an Array

//declare and then set values
var arr1 [2]string
arr1[0] = "Let's"
arr1[1] = "Rock"

//declare and initialize values in one step with a composite literal{} and the short assignment operator
arr2 := [4]int{5, 6, 4, 3}

//use ellipsis to have Go count the number of elements
arr3 := [...]float{
    3.14,
    4.13,
    5.67,
    43.55,
    100.12,
    1.0,
}
//the trailing comma is required when the composite literal is spread across multiple lines

The composite literal combined with the ellipsis gives us a simple, concise way to declare arrays.

Ranges

We can easily loop over elements of our array with a classic C-style for loop.

for i := 0; i < len(array); i++ {
    fmt.Println(array[i])
}

But Go offers us a new reserved word that makes iterating through arrays simpler and less prone to out of bounds errors: range.

//range in action
for i, name := range names {
    fmt.Println(i, name)
}

In this example range gives us the index and name from each iteration of our array of names. If we don't care about the index, we can use the blank identifier (an underscore).

for _, age := range ages {
    fmt.Println(age)
}

Passing Arrays to Functions

Two important things to remember: the length of an array is part of it's type and arrays are passed by value.

package main

import "fmt"

func paint(arr [2]string) {
    for i, _ := range arr {
        if i % 2 == 0 {
            arr[i] = "Red " + arr[i]
        } else {
            arr[i] = "Green " + arr[i]
        }
    }

    fmt.Println(arr)   //outputs [Red House, Green Couch]
}

func main() {
    arr := [2]{"House", "Couch"}
    paint(arr)
    fmt.Println(arr)   //outputs [House, Couch]
}

In this function we can see that our arr in main is not affected by the "painting" our paint function executes and if we added an element to our arr like this: arr := [3]{"House", "Couch", "Car"}, we would also need to change our paint function to accept arrays with type [3]string.

Slices

Now that we are familiar with the limits of arrays, we can talk about versatile slices! Slices are views or windows into arrays. Slices can view an entire array or just a portion of it. Rob Pyke wrote an excellent article on slices that definitely clear things up. Here's a quick definition of slices straight from the article:

A slice is a data structure describing a contiguous section of an array stored separately from the slice variable itself. A slice is not an array. A slice describes a piece of an array.

Creating Slices from Arrays

Let's look at a quick example.

//declares a food array
food := [...]string{
    "Carrot",
    "Broccoli",
    "Potato",
    "Corn",
    "Strawberry",
    "Apple",
    "Peach",
    "Watermelon",
    "Rice",
    "Wheat",
    "Amaranth",
}

//3 different slices, all pointing to different parts of the same food array
veggies := food[0:4]
fruits := food[4:8]
grains := food[8:]

In this example we are grabbing slices of our food array using half-open ranges. This means the first index specified in the range is included in the slice but the second is not. And in our grains slice declaration you can see that leaving off the final index lets the Go compiler know we want a slice from index 8 to the end of the array. We can do the same thing with the beginning of the array by leaving off the first index: veggies := food[:4] or we can get a slice of the whole array by not specifying any indexes: foodSlice := food[:].

Declaring Slices

We can also declare slices without explicitly declaring an array first (the compiler creates an array for the slice to point to).

legumes := []string{"Soy", "Lentil", "Pea", "Peanut"}

The only difference from declaring an array with a composite literal and a slice is the empty [], because we don't need to specify a length on our slice.

Passing Slices to Functions

Unlike arrays, slices have the ability to be altered (and the underlying arrays they point to) in other functions. Also, because slices don't have a length tied to their type, different sized slices can be passed to the same function. Let's look at an example that will capitalize the first letter of our food array.

package main

import (
        "fmt"
        "strings"
)

func capWords(words []string) {
    for i, w := range words {
        words[i] = strings.Title(w)
    }
}

func main() {
        food := [...]string{
                "carrot",
                "broccoli",
                "potato",
                "corn",
                "strawberry",
                "apple",
                "peach",
                "watermelon",
                "rice",
                "wheat",
                "amaranth",
        }

        veggies := food[0:4]
        fruits := food[4:8]
        grains := food[8:]

        capWord(veggies)
        capWord(fruits)
        capWord(grains)
        fmt.Println(food)
}

As you can guess, when we print our food array, it has been altered thanks to our slices and even though not all of the slices are the same length, the compiler does not complain! Yay slices!!

Appending to a Slice

Arrays can't grow, but slices can. This may seem strange considering our slices are just windows into our array. This is why it is important to know what is going on under the hood when we append to our slice. Here is a quick example that we can learn more from.

flowers := []string{"Ranunculus", "Daisy", "Daffodil"}
fmt.Printf("Length: %v Capacity: %v\n", len(flowers), cap(flowers))
flowers = append(flowers, "Tulip")
fmt.Printf("Length: %v Capacity: %v\n", len(flowers), cap(flowers))

Using the the built-in functions append, cap and len, we can add elements to our slice of flowers and see how many elements flowers contains and how much room it has (the capacity). When we run this code, we can see that the length increased by 1 after appending "Tulip", but capacity changed in a not so predictable way. Initially set to 3 because of our 3 flowers and then it doubled to 6. Here is where we can deduce that Go made a new array with a larger capacity. This is how slices are able to grow! Go makes an array with a capacity for the initial elements and then copies those values to a new array when we append items to our slice. Neat!

NOTE: append is a variadic function meaning it can take any number of items

Conclusion

Arrays give us the ability to keep track of collections of data. Slices allow us to work with arrays on a higher level of abstraction in order to do dynamic things with arrays!

Functions

Samuel Grasse-Haroldsen — Sun, 18 Apr 2021 20:49:10 +0000

Function Declaration

Declaring functions in Go is very straightforward. In fact, we have already declared a function in all of our programs so far. The main function is required in every binary executable (a program we want to run on its own, not a library we want to share). As with loops and conditional statements, we need to follow the "one true brace style."

package main

import "fmt"

func main() {
    fmt.Println("We are finally talking about functions!")
}

Let's go ahead and declare a more complicated function outside of main. add will take two integers and return an integer.

package main

import "fmt"

func add(x, y int) int {
    return x + y
}

func main() {
    sum := add(2, 3)
    fmt.Println("The sum of 2 + 3 is", sum)
}

func add
With the keyword func we are telling the Go compiler add is a function.
(x, y int)
In the parentheses we are declaring the names of our parameters x and y. We also need to tell the compiler what type of arguments to expect. Here we are saying the arguments should both be of type int. We could alternatively declare each parameter type like this: func add(x int, y int).
int {
After our list of parameters we need to declare what type of data add will return, in this case int. If we don't return anything in function we leave this part blank ex) func printLine(msg string) {
return x + y
In our function body we return the value of x and y added.

NOTE: There is no implicit return like in Ruby.

Returning

In Go you can return multiple values!

func addAndSubtract(x, y int) (sum, difference int) {
    sum = x + y
    difference = x - y
    return sum, difference
}

Here we are still taking two ints, but now we are returning their sum and their difference! Note the use of parentheses when we return more than one value (this is necessary). In this example we can also see that Go allows us to name our return values; though, it is not necessary. We could have alternatively written this: func addAndSubtract(x, y int) (int, int). When we name our return values they are initialized to their zero value (we don't need to explicitly initialize them in our function body).

NOTE: It is important to remember that although we can always return any number of values in Go, this functionality should not be abused as it can lead to avoidable complexity.

First Class Functions

Go functions are first class. This means you can assign them to variables, send them as arguments to other functions, and even return functions. There are also function literals in Go AKA anonymous functions, as well as closures. JavaScript developers should feel right at home with this functionality.

package main

import "fmt"


func addNumber(number int) func(int) int {
    return func(num int) int {
        return number + num
    }
}

func main() {
    add42 := addNumber(42)
    fmt.Println(add42(10)) //prints 52
}

This example demonstrates how to write a function literal, return a function, assign it to a variable, and create a closure. Let's go through the code step-by-step.

func addNumber(number int) func(int) int {
We are declaring our function addNumber here. It will take an argument called number of type int and addNumber will return a function. It may seem superfluous, but we must tell the Go compiler what kind of function addNumber will return. func(int) int is simply the type signature for the function we are going to return. The function we are returning will take an int as a parameter and return an int value.
return func(num int) int {
This is where we are returning our anonymous function (called a function literal in Go). It will take an int as an argument and return an int value.
return number + num
We are simply returning the parent function's number argument added to the function literal's argument num.
add42 := addNumber(42)
Here we are assigning the return value of addNumber (our function literal) and assigning it to the variable add42. add42 now points to a function that will add whatever number we pass it with 42 because that was the number we passed to addNumber when we initialized add42. This is where the closure is created.

Simplifying With Custom Types

In a statically typed language we need to tell our compiler what kind of data our variable should hold. Go has a number of built-in basic types such as int, float, bool, and string, but we can also declaring our own types! This will make our last example a little cleaner. Enter another reserved word: type!

package main

import "fmt"

type addClosureFunc func(int) int

func addNumber(number int) addClosureFunc {
    return func(num int) int {
        return number + num
    }
}

func main() {
    add42 := addNumber(42)
    fmt.Println(add42(10)) //prints 52
}

It is extremely simple to declare a new type. You simply need a name for the type: addClosureFunc and the underlying implementation func(int) int. We can even add names to our parameter and return value if we want, just to make things a little more clear.

type addClosureFunc func(sum int) (num int)

Conclusion

With the power to declare functions, pass them around like any other variable, and create our own types, we can really see the power Go gives us to create very maintainable, easy-to-follow code. Next week we will talk about methods.

Conditionals

Samuel Grasse-Haroldsen — Mon, 12 Apr 2021 05:07:22 +0000

We've already covered an example or two using if statements, but let's dig into the syntax required by ifs and switches. In today's post we're going to cover 6 more reserved words: if, else, switch, case, fallthrough, and default.

If

If statements are pretty standard in Go (similar to C and its derivatives). As always, it is important to remember "the one true brace style."

const amSam = false
name := "Samuel"

// good
if (amSam) {
        fmt.Println("I am Sam")
} else if name == "Samuel" {
        fmt.Println("I am Samuel")
} else {
        fmt.Println("I am not Sam")
}

// gives an error
if amSam 
{
       fmt.Println("I am Sam")
}

// gives an error
else {
        fmt.Println("I am not Sam")
}

It is also important to note that if we want to include an else or an else if we must do so on the same line as the previous conditional's closing curly brace. Also, we can put parentheses around the condition if we want.

Switch

Ahh switch statements. I can never remember their syntax, so I'm glad I'm writing it here for at least one language!

favCharacter := "Catbug"
switch favCharacter {
case "Jelly Kid":
       fmt.Println("We can be friends.")
case "Catbug":
       fmt.Println("Instant best friend.")
default:
       fmt.Println("Really?")
}

By default, if a case evaluates to true, control leaves the switch block. This means if we have multiple case statements that could be true only the first executes. If we do not want this behavior, we can use the fallthrough keyword:

num := 5

switch {
case num < 10 :
       fmt.Printf("%v is less than 10\n", num)
       fallthrough
case num < 15:
       fmt.Printf("%v is less than 15\n", num)
       fallthrough
case num > 20:
       fmt.Printf("%v is greater than 20\n", num)
}
// every case is executed

IMPORTANT: It is only recommended to use fallthrough if the behavior is clearly understood. As we can see in the example, even though 5 is not greater than 20, the preceding case contains the fallthrough keyword, thus, 5 is greater than 20 will be printed.

Also, notice in the last example how we don't have to include a variable after switch? This is called an expressionless switch statement. We are just checking some conditions in each case. They don't have to (but probably should be) related.

We can have multiple conditions in a single case, but it is important to note that duplicate cases are not allowed.

// good
color = "yellow"
switch color {
case "red", "yellow", "blue":
       fmt.Println("A primary color")
case "orange", "green", "purple":
       fmt.Println("A secondary color")
default:
       fmt.Println("A new color?")
}

// error: duplicate case
switch color {
case "yellow":
       fmt.Println("A primary color")
case "yellow":
       fmt.Println("The best primary color")
}

Conclusion

Always remember the "one true brace style" and avoid using fallthroughs if you can!

Variables & Types

Samuel Grasse-Haroldsen — Mon, 05 Apr 2021 04:46:26 +0000

Today we're going to talk about how to declare variables and some data types in the Go language.

Variables

Variables can be declared in a few different ways in Go. We can declare a variable with the var keyword, or if we want to declare a constant, we can use the keyword const.

var gopherAge = 11
const gopherMood = "happy"

Declaring Type

We can also declare the type of our variable (identifier) if we want to. This is generally discouraged as the Go compiler can infer the type a variable should be by it's initial assignment. This is how we explicitly declare type.

var gopherAge int = 11
const gopherMood string = "happy"

The Short Method

But there is another way we can declare variables. A more concise way. The "short method." NOTE: This shorter syntax is only available for non-constant variables.

gopherColor := "blue"

Declaring Multiple Variables

We can also declare multiple variables using either of the following methods.

const (
        gopherCreator = "Renee French"
        gopherNumEyes = 2
)

// OR

const gopherCreator, gopherNumEyes = "Renee French", 2

The Short Method Advantage

It is important to know that we can use the short method of variable declaration in places that the longer method (using var or const keywords) cannot be used.

for year := 2009; year < 2021; year++ {
        if age := year - 2009; age == 1 {
            fmt.Printf("In %v, the gopher was %v year old.\n", year, age)
        } else {
            fmt.Printf("In %v, the gopher was %v years old.\n", year, age)
        }
}

We are declaring & initializing the variable year in our for loop and we are also declaring the variable age in our if statement. This is not possible using var or const.

Types

In a statically typed language such as Go, identifiers (variables) are associated with a specific type of data. There are a number of different types in Go, some basic common types include:

int : a whole number (negative or positive)
uint : a positive whole number
float : real numbers (can contain decimals)
bool : true or false
string : a collection of characters

Gopher Bytes

It is hard to talk about data types without talking about how those variables are stored in memory. As we all know, computers just use 0s and 1s to do a whole range of things, so every time we declare a new variable, really we are just setting aside a certain amount of 0s and 1s (bits) for the computer to store something for us. This can be a name, an address, an age, anything. In Go, the compiler will take care of inferring what type of data we want, but we can explicitly declare what type of data a variable should contain. Go allows us to get even more granular and declare how many bits we need:

var red, green, blue uint8 = 3, 236, 252

Here we are declaring three variables of type int8: red, green, and blue (AKA an RGB value). Why we specified the type as uint8 is because RGB values are always whole numbers between 0 and 255. We could have just let the compiler infer a type of int, but that means our tiny RGB values would take up a whopping 32 or 64 bits of memory, depending on our computer's underlying architecture, instead of just the 8 they would need. Obviously modern computers can handle quite a bit of this inefficient memory usage, but if we need to, we can optimize and use only the bits we need. Another bonus is that if we try to assign one of these values to a value above 255, the compiler will give an overflow error.

Conclusion

Statically typed languages have many advantages. At first declaring types may seem mundane and unnecessarily complicated, but having that ability to declare types coupled with a compiler that can quickly check our code for errors gives us the ability to catch issues before testing, optimize where we want, and improve readability.

Why Learn Go?

Samuel Grasse-Haroldsen — Sun, 28 Mar 2021 21:53:50 +0000

I recently started attending a local Go meetup (virtually for the time). It has been quite an eye-opener learning a totally new language and not just another framework. Plus, Go is a statically typed language, quite different from the dynamically typed languages I have experience with such as Ruby and JavaScript. It's been quite a fun language to play with so far, and maybe one day I'll confidently refer to myself as an expert gopher. At any rate, I want to document my journey, so here is the first in a series of blog posts on Go.

The Origin of Go

You can read more about the origin of Go, along with other topics related to the language, at golang.org/doc/faq. To summarize, some developers at Google were frustrated with how complicated their code was using languages like C++ and Java. They wanted to create a new language that would be simpler to use. Simplicity is a key component of Go. One of the creators credits simplicity as the reason behind the language's success. This simplicity applies to some very complicated aspects of programming including concurrency, but we'll get into that later.

Why Go?

Reading more into the origin story can also answer the question of why someone should use Go in a project. Go is simple to use and fast. There are stories of people using Ruby on Rails and having scaling issues, like iron.io going from 30 servers to 2 by rewriting their API in Go. In the blog post, Dylan Stamat talks about having fun writing Ruby, not wanting to write more Java, and ultimately deciding on Go. Like Ruby, a lot of developers enjoy writing Go. That, combined with the fact Go is super easy to deploy (compiling a single binary) makes Go a great choice for many tasks!

Playing with Go

Now that we have some background let's dive into the language! If you want to install Go on your machine here is a link with all the instructions golang.org/doc/install, but if you don't want to for whatever reason, you can code in the cloud on play.golang! Quick tip: if you write some code in the go playground and hit share, your code will be saved to that url and you can revisit it or share it with others. Ex. a little code for the readers

Hello Devs

If you didn't have the courage to click on the last link, fear not, I will include the code here. Every great tutorial should include a print statement with the phrase "Hello, world." So here it is in Go.

package main

import "fmt"

func main() {
        fmt.Println("Hello, devs!")
}

Although simple, this simple program touches on some key concepts of Go.

package main

We are declaring our package with the name main to let the Go compiler know that we want this package to compile to a binary executable instead of a shared library.

import "fmt"

Here we are importing the fmt (format) package which is part of the standard library. This is how easy it is to include another library! Important: Go does not like unused code. If you import a package and don't use it, the compiler will give you an error message.

func main() {

This is pretty standard stuff if you come from a C family language. Our program begins to execute in the main function. Important: Go follows the "one true brace style". This means an opening curly brace at the end of a line and not on a new line. Thanks to this strict policy, we don't have to tire our pinkies typing semicolons.

// good
func main() {
}

// unacceptable
func main()
{
}

fmt.Println("Hello, devs!")

Here we are accessing the fmt package and calling its function Println using OOP's familiar dot notation. Important Go is not an OOP language

Conclusion

We didn't go over too much, but now you are familiar with three of Go's 25 reserved keywords: package, import, and func. Next week we'll go over variables and types.

Deleting with React & Redux

Samuel Grasse-Haroldsen — Sun, 21 Mar 2021 21:43:58 +0000

I recently added delete functionality to to my flashcard/quiz application, Flipr Quiz. This may not sound super exciting to people, but adding this functionality really helped me review so many parts of the front-end: React events, Redux actions and reducers, higher-order functions, and more.

Flipr Quiz

I originally designed my app to be simple, eye-catching, and functional. It is made up of two resources: stacks and cards. Users create a stack with a title and then add cards (front and back) to a certain stack. Today we'll only cover deleting stacks.

The Back-End

This post is about React and Redux so I won't go to into the back-end, but I will say I like to start adding new features on the back-end. This way I know that my back-end isn't the problem while testing on the front-end. Using Ruby on Rails all I need to do is add a destroy method to my stacks controller and make sure I have dependent_destroy listed on the card relationship on my stack model (I want cards to be deleted when a stack is deleted).

React

Now that my back-end is ready to destroy stacks, I like to get something visual on the page. I add a "Delete this stack" button to the stack view page.

<button onClick={this.handleClick}>
  Delete this stack
</button>

I know I don't have a handleClick method in this class, so I write that next. I'll need the stack's id because my back-end needs to know which stack to delete. I'll also need to access the history object to alter our URL. I'm using React Router which gives me access to additional props like parts of the URL ex) params, history. Read more about match and history at reactrouter.com.

handleClick = () => {
  const { history } = this.props;
  this.props.deleteStack(this.props.match.params.id, history);
};

I don't have a deleteStack action yet, but I'll go ahead a map it to props before I forget.

const mapDispatchToProps = (dispatch) => {
  return {
    deleteStack: (id, history) => dispatch(deleteStack(id, history))
  };
};

Redux

Now I'll go ahead and finally add the deleteStack action to my stacksActions.js. (btw I'm using redux-thunk to do async things)

export const deleteStack = (id, history) => {
  return (dispatch) => {
    fetch(`http://localhost:3000/stacks/${id}`, {
      method: "DELETE",
      headers: { "Content-Type": "application/json" },
    })
      .then(() => history.push("/stacks"))
      .then(() => dispatch({ type: "DELETE_STACK", payload: id }));
  };
};

So this is where all the magic happens. Three things are specifically happening:

We are making a delete request to our back-end
We are taking the user back to the view of all the stacks
We are dispatching our DELETE_STACK action with the id of our stack as the payload

Stack Reducer

Now that we have our action we need to add how our state should change based on this action in our reducer!

switch (action.type) {
...
  case "DELETE_STACK":
    return {
      data: state.data.filter((stack) => stack.id !== action.payload),
    };
...

Here we are filtering out the specific stack that we just deleted using our payload (the stack's id). Now our stack has been deleted on the back and front end!

Refactoring Ruby with Regex

Samuel Grasse-Haroldsen — Mon, 15 Mar 2021 05:50:56 +0000

The project

I am currently working on an exciting project with a friend of mine. This application uses a bot that interacts with different social media sites and determines if a post has relevant information about a specific stock. If the post does have relevant information the bot persists the post to an API where we have different access points depending on what the user wants to see on our front-end (most mentioned stocks in the last 24 hours, week, month, year). One of the most challenging and enjoyable parts so far for me has been working on the algorithm on the bot to determine if a post mentions a specific stock.

Tickers

Before we get into how to find relevant data, we need to talk about how people normally mention stocks on the internet. Stocks have long names and they also have tickers or symbols that allow people to quickly reference a specific stock.

Company Name	Ticker
Game Stop Corp.	GME
AMC Entertainment Holdings Inc	AMC
Rocket Companies Inc	RKT

While some people may say Game Stop or Nokia they will rarely if ever say a stock's complete name. Tickers are generally preferred thanks to their brevity and specificity. Another important thing to know is that tickers are often placed after the dollar sign like this: $NIO. This isn't always the case, but it happens often enough to warrant knowing.

check_if_relevant

Without going into the nitty-gritty details, I will tell you that my friend captured all the relevant stock data (names, tickers, etc.) into a database using .CSV (comma separated value) files. Now that we have our stocks and their tickers we can set up our check_if_relevant method. We will loop through each stock, grab the stock's ticker, and send it (along with the post) to another function called contains_ticker?.

def check_if_relevant(post)
  @stocks.each do |s|
    if contains_ticker?(post, s["symbol"])
      # Save post here
    end
  end
end

contains_ticker?

This is where things get interesting. I know I have sang Ruby's praises before, but working with strings is extremely intuitive and fun in this gem of a language (thanks Matz!). Checking if a sentence contains a word is super simple!

"Ruby is fun!!!".include? "Ruby"
=> true

See how easy and painless that was? One line, no loops, it just works. This was my initial solution, but I soon realized the bot was saving a lot of false positives. Some of the tickers were common words or only one character long. I needed to add logic. I would revise the ticker by adding spaces and if it was too short or a common word I would add a $.

def get_revised_symbol(symbol)
  if symbol.length <= 2 || COMMON_WORDS.include?(symbol)
    '$' + symbol + ' '
  else
    ' ' + symbol + ' '
  end
end

def contains_symbol?(post, symbol)
  post.include? symbol
end

This was my initial approach, but I realized I would need something I could be more specific with (sometimes people would add punctuation to the end of the ticker and not a space). Enter regex.

Regular Expressions

Without going too much into what regex is, I will quote MDN

Regular expressions are patterns used to match character combinations in strings.

The perfect, elegant solution to my problem! Now I just needed to look up all the cryptic symbols and what each did (I feel like learning a new programming language is 75% this). I had two awesome resources to help accomplish this and I recommend you check them out. Read about using regex in Ruby at rubyguides.com and actually play around with it at Rubular.

Onward

I wanted to basically allow any punctuation before or after the ticker but still add the $ under the same conditions. I jumped through several iterations while reading about regex including this beast:

   def contains_symbol?(post, symbol)
     if symbol.length <= 2 || COMMON_WORDS.include?(symbol)
       return post.title.match(/[!,.?:;"' #%^&()$]+$#{symbol}+[!,.?:;"' #%^&()]/) || post.selftext.match(/[$!,.?:;"' #%^&()]+$#{symbol}+[!,.?:;"' #%^&()]/)
     else
       return post.title.match(/[!,.?:;"' #%^&()$]+#{symbol}+[!,.?:;"' #%^&()]/) || post.selftext.match(/[$!,.?:;"' #%^&()]+#{symbol}+[!,.?:;"' #%^&()]/)
     end
   end

Ugly right? Turns out I needed to practice some patience and read the entire article and experiment before implementing a solution. Regex exists because it has some very useful built-in ranges. I found \w covered all numbers and letters, so I would use that but add ^ to negate it. Then I read on to discover that \W is equivalent to ^\w. So here is my final solution:

def contains_symbol?(post, symbol)
  if symbol.length <= 2 || COMMON_WORDS.include?(symbol)
    return post.title.match(/[\W]$#{symbol}[\W]/) || post.selftext.match(/[\W]$#{symbol}[\W]/)
  else
    return post.title.match(/[\W]#{symbol}[\W]/) || post.selftext.match(/[\W]#{symbol}[\W]/)
  end
end

Conclusion

In closing, using cool new features in a language can make code cleaner, coding more enjoyable, and also a little painful if you don't fully understand what you're doing! Read the docs!

CSS Selectors

Samuel Grasse-Haroldsen — Mon, 08 Mar 2021 02:56:43 +0000

After a suggestion from my mentor on a Firefox issue I'm currently working on, I replaced 20+ lines of JavaScript code toggling a message to 3 lines of CSS. A lot of developers, myself included, can benefit from understanding just how far CSS can take a website.

The Problem

As I mentioned already, the issue I'm working on boils down to displaying a message if the user has no addons and if the user does, hiding that message. To get a working solution I wrote a JS method to create the message and then a method that would toggle the display attribute of the message element. Upon reviewing my code, my mentor suggested using the ~ selector. I had never heard of it so I did some research.

CSS Selectors

I'm was familiar with selecting an element either using the name, id, or class of the element.

/* selects all the p elements */
p {
  color: blue;
}

/* selects all elements belonging to the class error */
.error {
  color: red;
}

/* selects the element with the id green-message*/
#green-message {
  color: green;
}

I also knew about chaining these selectors together.

/* selects all button elements belonging to the warning class */
button.warning {
  background-color: yellow;
}

But I didn't know how many selectors there were and all the possibilities. Here are just a few examples!

/* selects all img elements in the image-container class */
.image-container img {
  margin: 5px;
}

/* selects all img elements that have the image-container class as a parent element */
.image-container>img {
  margin: 9px;
}

/* selects the first img element placed after an element belonging to the image-container class */
.image-container+img {
  margin: 7px;
}

/* selects p elements when user hovers over them */ 
p:hover {
  text-decoration: overline;
}

/* Selects every h2 that comes after a p element */
p ~ h2 {
  color: pink;
}

There are a ton more CSS selectors and you should definitely check them out on w3schools.

Back to Firefox

I've been saving this for last because honestly it was just so mind blowing that I could use a style sheet to accomplish this task. Here it is:

section:not(:empty) ~ #empty-addons-message {
  display: none;
}

Now what these selectors do in conjunction is select the element with the id #empty-addons-message that comes after a section element when that section element is not empty. Pretty crazy the kind of logic you can code into your style sheets! Next time you are considering adding some display logic see if you can use CSS to accomplish the task!