This is how I wrote it in an attempt to keep track of what’s going on:

> +++++ +++++ +++++
[
< +++++
> -
]
>
<
.

Here’s it without the spaces:

>+++++++++++++++[<+++++>-]><.

What does this program do, you might ask?

All it does is output the letter ‘K’.

EDIT (April 4, 2026): idk what happened but the above code doesn’t work.

The corrected version is:

>+++++++++++++++[<+++++>-]<.

In general, the way I avoided debt in college was this:

• I chose a college with pretty low tuition costs
• I got good grades (and a good ACT score)
• I worked

Let’s go in order of that list.

First, I went to a college with low tuition costs: Brigham Young University (BYU). Their tuition for full tithe-paying members of the Church of Jesus Christ of Latter-day Saints is ridiculously low. We’re talking $3/3.5K per semester, so less than 7 thousand bucks a year for full-time undergraduate students. It really helps to go to a university with low tuition costs. BYU is constantly ranked as one of the best value higher education institutions, so keep that in mind when you’re looking at colleges.

Next, I got good grades (and a good ACT score). The first 3 semesters at BYU I got a half tuition academic scholarship based on my high school GPA/ACT (I had a 3.9 GPA and got a 32 on the ACT). The last 4 semesters of my undergrad I got full tuition academic scholarship based on my GPA at BYU. So basically I got good enough grades at BYU to make the cut-off for full tuition.

I must say, half tuition was alright, but full tuition was awesome.

Finally, I worked. I needed money. I got a job at Jiffy Lube right when I moved up to Provo. I worked there for about a year and a half. It was good to learn a few things about car maintenance and customer service. But it was also good because I needed to pay the rent, foot the grocery bill, and come up with the other half of the tuition, which was about 3K a year. My first semester of college was pretty easy, so I worked 28-30 hours a week. Most of the time after that I worked significantly less (15-20 hours a week), but I did what I had to to pay for my expenses and not dig myself into a financial hole.

I left Jiffy Lube to go work in the laundry at the Provo City Center Temple. It was awesome. I got really good at folding pants, socks, slips, nylons, and more. (I also got paid like 2 or 3 dollars more per hour).

After six months, I got a job working on the content for language learning software through a friend of a friend. That paid another 2 or 3 dollars an hour more per hour. A few months went by and I finagled my way into a computer programming job working on the language learning software, and I got a raise for that as well.

I’ll stop there, since the point of this is that I always had a job, I was always working. I never stopped working just so I could concentrate on my school work. I know that might work for some people if their parents are paying for their school, or they were smart and saved enough to live on during school. Working was a necessity for me if I wanted to continue going to school and living in my apartment and eating my food.

Besides low tuition, another thing to consider is the difficulty (and length) of your major. My major - Spanish translation - is pretty easy when compared to other majors like mechanical engineering or exercise science. It also only had 37 required credit hours, which means I finished rather quickly while still having space in my class schedule to pursue other interests (e.g. a minor in computer science, which is what I did).

So there you have it. In summary:

• Find a college with lower tuition costs.
• Get good grades (in high school and college).
• Work - get a job (or two).
• Also, choose an easy major if you can; otherwise, don’t.

There’s my not-so-expert advice, but it’s the best I’ve got.

• I don’t use Xcode. Okay, I’ve “used” it once, and that was tonight for like 5 seconds. Never again.
• I use a Mac for work because that’s what they gave me.
• My OS of choice is definitely Linux. I run Ubuntu 20.04 and use it for everything except work.
• I have an Android phone.

Now that we’ve veered off course a bit, here’s a quick bulleted summary of my study of languages during the first 25 years of my life.

• Had Spanish in home school, mostly remember singing
• 2nd-4th grade, Spanish immersion program
• 8th-10th grade, took German for three years.
• 11th-12th grade, took Spanish 3 and AP Spanish. Scored a 3 on AP Spanish test
• Spent 2 years speaking and studying Spanish every day in Texas on a mission for the Church of Jesus Christ of Latter-day Saints.
• Studied Spanish Translation at BYU, graduated with B.A. in 2019

In addition to the above, I’ve had many opportunities to practice speaking Spanish in almost every job I ever had. For example, I had native Spanish-speaking coworkers in 4 of 7 jobs. I also took care of Spanish-speaking customers at Jiffy Lube.

I also have always made friends from other countries and cultures and tried to learn their languages, always asking how to say things, if I’m saying things right, etc. As I’m writing this I realize I have had less interaction with non-native English speakers recently. To be fair, I’ve had less interaction with literally everyone since coronavirus happened, besides my wife and son of course. Another thing I realize is I don’t really have anything on the list after graduating from BYU. I’m going to change that. Stay tuned.

Since March, I have mostly just sat on my rear all day, gone on evening walks with my wife and kid, and every so often join my wife for an arm or ab workout in the morning. Then I decided to start running again. For about a month, I would get up Monday morning and go run a couple miles. Then the rest of the week - nothing.

Then one Sunday afternoon I was talking to my brother in law. He’d recently lost a decent bit of weight and was looking healthy. I asked him how he did it, and he said it was watching his calories and macro nutrients (fats, carbs, proteins). Well, I had tried counting calories before, but didn’t stick with it for super long. This time I figured I’d give it another go.

I downloaded the MyFitnessPal calorie counter app and started keeping track of everything I ate (again). I also downloaded MapMyRun to keep track of my running times and distances. Turns out I could also use Samsung Health for that, but I haven’t tried it out yet. Anyway, I kept track of my calories for 2 or 3 weeks, then slowly stopped logging everything. BUT, I haven’t stopped running :grin:.

Running has been so great. It’s been about six weeks now that I’ve been running 3 to 5 times a week. I usually go about 6am, give or take a few minutes. Most mornings it’s around 62 degrees Fahrenheit, which is a beautiful temperature if you ask me.

Stats

The farthest I’ve ran this month is 6 miles, took me just over an hour.

The fastest mile I’ve ran this month is 7 minutes and 35 seconds.

The fastest three miles I’ve ran this month is 26 minutes and 27 seconds (averages of 8:48 per mile).

The total distance I’ve ran this month so far is 46.2 miles.

The other day I saw someone on Twitter say they were running 100km to support some charitable cause. I think that’s very noble. I’m not supporting any specific cause with my running, but I liked the idea of 100km. It’s a nice even number. So that’s my goal by the end of July 2020 - run at least 100km. 100km is about 62.something miles, so I have about 16 miles left to run in the next week. I’ll make sure to come back and add a quick update about how I did, and my new stats and whatnot.

Update

I did it! (picture forthcoming, once I find it)

For now, I’ll make a skeleton list and fill out each section when I have time.

Hello World in Go

To get you familiar with the syntax of Go, here’s an example program that prints “Hello World!”

package main

import "fmt"

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

Packages

Go is organized into packages. Every go file has to belong to a package. If you’re wondering, this is much less irksome than Java’s requirement that everything belong to a class. To say what package a Go file is in, you put package <packagename> at the top. Every package is confined to a directory, meaning you can’t have .go files with different package names in the same directory. The main package is called main, which is the oddest of all.

That’s all I’m going to say for now about packages. Nothing too odd there, but it’s helpful background for the next section.

Private/public

Many languages have some kind of way to specify whether a variable, function, variable, or class is public or private (or protected, etc). In C++ and Java, you use key words like private and public to make this distinction. Python typically uses underscores to signify private, or at least you shouldn’t rely on it as part of its public API, but it’s not enforced by the language. In Go, “private” things start with a lowercase letter, while “public” things start with uppercase letters. A package only exports the identifiers (variables, functions, etc) that start with an uppercase letter. All identifiers declared in a package are available throughout that package, whether they start with upper or lowercase.

Let’s do a little example.

Here are the contents of example1.go:

package example

var myPrivateThing = "asdf"

var MyPublicThing = "jkl;"

In this case, myPrivateThing is available throughout package example. If I had another file example2.go, I could access everything defined in example1.go.

package example

import "fmt"

func printSomething() {
  fmt.Println(MyPublicThing) // success
  fmt.Println(myPrivateThing) // success
}

MyPublicThing could be accessed from any package that imports package example, but myPrivateThing cannot. Here’s an example of that in a theoretical main.go:

package main

import (
  "fmt"
  "some/path/to/example"
)

func main() {
  fmt.Println(example.MyPublicThing) // succeeds
  fmt.Println(example.myPrivateThing) // error
}

Declaring variables

When you declare a variable in C or C++, it might look something like this:

int i = 1;

In Go, you can achieve the same like so:

var i = 1

In this case, the Go compiler is smart enough to figure out that iis an int. There are a few other ways to declare variables in Go. For example, you can declare the type explicitly:

var i int

and then define it later:

i = 1

There’s also this nice shorthand operator you can use that you’ll likely see more often than not in Go source code:

i := 1

This means something like declare the variable *i*, and make it equal to 1.

Semi-colons?

Unlike C, C++, and Java, you almost never need to use semi-colons in Go (but you can). Technically, Go uses semi-colons to terminate statements, but the lexer inserts most of them for you. This takes some getting used to. Semi-colons are probably the thing I mess up the most often when switching between languages.

Function signatures

The signature of a function is basically what you would include in a C or C++ header file. It defines the return type of the function (void, int, char *, etc), the function’s parameters (if any), and the name of the function.

For example, here’s a C function that tells you if one number is divisible by another number:

int isDivisibleBy(int dividend, int divisor)
{
    return dividend % divisor == 0;
}

In Go, it would look like this:

func isDivisibleBy(dividend int, divisor int) int {
    return dividend % divisor == 0
}

A few differences to note:

• When you write a function in Go, you use the word func.
• The types of the parameters come after their names, whereas in C the types come before the names
• The return type of the function comes after the parameter list, and before the open curly brace.

The above function could also be written like this:

func isDivisibleBy(dividend, divisor int) int {
    return dividend % divisor == 0
}

Notice this time I didn’t include the first int. If you don’t include the type of a parameter, it will take the type of the next parameter to the right that has a type. So if you have 100 parameters and they’re all of type string, you only have to write string for the very last (rightmost) one.

Naked returns and named return parameters

This is one of the oddest parts of Go syntax (or coolest, depending on your point of view).

Take the following function in Go:

// Max takes a slice (a.k.a. a list) of ints, and returns the one with the largest value 
// If the slice is empty, it will return an error
func Max(numbers []int) (int, error) {
    var max int
    if len(numbers) == 0 {
        return max, errors.Error("Slice is empty!")
    }
    max = numbers[0]
    for _, n := range numbers[0:] {
        if n > max {
            max = n
        }
    }
    return max, nil
}

As the comment says, this is a simple (naive) function to get the max value of a slice (a slice is kind of like an array or a list). It has multiple return values: an int, and the other is Go’s builtin error type. Multiple return values in Go is very common. It’s also very common for one of them to be error.

To illustrate what I mean by “naked returns” I’m going to rewrite the function slightly:

func Max(numbers []int) (int, error) {
    var max int
    var err error
    if len(numbers) == 0 {
        err = errors.Error("Slice is empty!")
        return
    }
    max = numbers[0]
    for _, n := range numbers[0:] {
        if n > max {
            max = n
        }
    }
    return
}

You’ll notice I changed three lines:

• I added the line that declared err (var err error)

… Oops, out of time. I’ll finish this section later this week.

If you’re interested in making your own blog and you like the look of this one, I forked jekyll-now to get up and running with Github Pages. It was super easy to setup, so thanks to everyone who’s worked on that.

I remove tagging, seemed kinda bloaty, especially for how often I post.

I may add some more styling to the blog as it goes on, and I haven’t decided about comments yet.

For now, expect to see some posts coming soon about Go, Python, and the Domain Name System (DNS). I’m also planning on posting about open source project ideas that I think of or hear about.

Stay tuned!