Linked lists are primarily used when data access is desired to be sequential in nature. This means accessing y will always come after x.

# Bubble Sort

Bubble sort is a sorting algorithm that iterates through an array, comparing two elements at a time and swapping if appropriate. On each pass, at least one value is placed in its final sorted location (though it is possible that more are also placed in their final location).

# Function to Find Anagrams

For a technical interview over video chat for an API Developer position, I was asked to write a function while sharing my screen that would compare two strings and determine whether or not they formed an anagram. This article outlines my approach to solving the problem.

# Computing runtime for the Fibonacci Sequence

An exponential big-O is represented by: `O(c^n)`

The `n` in an exponential problem means that the time of each consecutive computation of `n` will increase by `c^n`.

Recursively computing the Fibonacci sequence is a simple example of exponential big-O problems. Let’s take a look:

``````package main

import "fmt"

func main() {
fmt.Println(fib(40))
}

func fib(n int) int {
if n <= 1 {
return n
} else {
return fib(n-1) + fib(n-2)
}
}
``````

# Error Handling in Golang

In the Go programming language, I often see errors being handled in a careless manner that is difficult to maintain. This common mistake has prompted me to make a video that demonstrates the basic fundamentals of error handling in Go:

The Effective Go guide points out the appropriate way to do error handling in Go and is a great place to turn for further reading.